pgRouting

Changeset 76

Show
Ignore:
Timestamp:
12/14/07 15:27:16 (1 year ago)
Author:
anton
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • sandbox/orkney/shootingstar.h

    r75 r76  
    144144    { 
    145145       
    146     //Vertex ids renumbering moved here 
    147     src = edges_array[j].source; 
    148     trg = edges_array[j].target; 
    149      
    150     if(vertices[src]==0) 
    151     { 
    152       vertices[src]=j+offset; 
     146      //Vertex ids renumbering moved here 
     147      src = edges[j]->GetFieldAsInteger(SOURCE_FEATURE); 
     148      trg = edges[j]->GetFieldAsInteger(TARGET_FEATURE); 
     149     
     150      if(vertices[src]==0) 
     151      { 
     152        vertices[src]=j+offset; 
     153      } 
     154      edges[j]->SetField(SOURCE_FEATURE, vertices[src]); 
     155     
     156      if(vertices[trg]==0) 
     157      { 
     158        offset++;       
     159        vertices[trg]=j+offset; 
     160      } 
     161      edges[j]->SetField(TARGET_FEATURE, vertices[trg]); 
     162     
     163      for(z=0; z<edges[j]->GetFieldAsIntegerList(RULE_FEATURE).size();++z) 
     164      { 
     165        if(edges[j]->GetFieldAsIntegerList(RULE_FEATURE)[z] > 0) 
     166        { 
     167          rule.push_back(edges[j]->GetFieldAsIntegerList(RULE_FEATURE)[z]); 
     168        } 
     169      } 
     170 
     171      if(edges[j]->GetFieldAsDouble(TO_COST_FEATURE) > 0) 
     172      { 
     173        adjacent_edges[edges[j]->GetFieldAsInteger(ID_FEATURE)].push_back( 
     174                                std::pair<float8, vector<int> > (GetFieldAsDouble(TO_COST_FEATURE), rule) ); 
     175        rule.clear(); 
     176      } 
     177 
     178      if((j < count-1 && edges[j]->GetFieldAsInteger(ID_FEATURE) != edges[j+1]->GetFieldAsInteger(ID_FEATURE))||(j==count-1)) 
     179      { 
     180 
     181        bool inserted = addEdge(e, edges[j], graph); 
     182 
     183        graph[*e].cost = edges[j]->GetFieldAsDouble(COST_FEATURE);//set cost 
     184        graph[*e].id = j;//set id 
     185 
     186 
     187        if (!IsDirected() || (IsDirected() && HasReverseCost())) 
     188        { 
     189 
     190          if(adjacent_edges[edges_array[j].id].size() > 0) 
     191          { 
     192            adjacent_edges[edges[j]->GetFieldAsInteger(ID_FEATURE)+e_max_id].assign(  
     193                              adjacent_edges[edges[j]->GetFieldAsInteger(ID_FEATURE)].begin(),  
     194                              adjacent_edges[edges[j]->GetFieldAsInteger(ID_FEATURE)].end() ); 
     195            adjacent_edges.erase(edges[j]->GetFieldAsInteger(ID_FEATURE)); 
     196          } 
     197 
     198          edge_descriptor *er;  
     199          //adding an edge for opposite direction 
     200          bool inserted = addEdge(er, edges[j], graph); 
     201 
     202          graph[*er].id = j;//set id 
     203     
     204          if (HasReverseCost()) 
     205          { 
     206            graph[*er].cost = edges[j]->GetFieldAsDouble(RC_FEATURE);//set reverse cost 
     207          } 
     208          else  
     209          { 
     210            graph[*er].cost = edges[j]->GetFieldAsDouble(COST_FEATURE);//set cost 
     211          } 
     212 
     213        }   
     214 
     215        adjacent_edges.clear(); 
     216        rule_num = 0; 
     217      } 
     218      else 
     219      { 
     220        rule_num++; 
     221      }    
    153222    } 
    154     edges_array[j].source=vertices[src]; 
    155      
    156     if(vertices[trg]==0) 
    157     { 
    158       offset++;       
    159       vertices[trg]=j+offset; 
    160     } 
    161     edges_array[j].target=vertices[trg]; 
    162      
    163     for(z=0; z<MAX_RULE_LENGTH;++z) 
    164     { 
    165       if(edges_array[j].rule[z] > 0) 
    166       { 
    167         rule.push_back(edges_array[j].rule[z]); 
    168       } 
    169     } 
    170  
    171     if(edges_array[j].to_cost > 0) 
    172     { 
    173       adjacent_edges[edges_array[j].id].push_back(std::pair<float8, vector<int> > (edges_array[j].to_cost, rule) ); 
    174       rule.clear(); 
    175     } 
    176  
    177     if((j < count-1 && edges_array[j].id != edges_array[j+1].id)||(j==count-1)) 
    178     { 
    179  
    180       bool inserted = addEdge(e, edges[j], graph); 
    181  
    182       graph[*e].cost = edges[j]->GetFieldAsDouble(COST_FEATURE);//set cost 
    183       graph[*e].id = j;//set id 
    184  
    185  
    186       if (!IsDirected() || (IsDirected() && HasReverseCost())) 
    187       { 
    188  
    189         if(adjacent_edges[edges_array[j].id].size() > 0) 
    190         { 
    191           adjacent_edges[edges_array[j].id+e_max_id].assign( adjacent_edges[edges_array[j].id].begin(), adjacent_edges[edges_array[j].id].end() ); 
    192           adjacent_edges.erase(edges_array[j].id); 
    193         } 
    194  
    195         edge_descriptor *er;  
    196         //adding an edge for opposite direction 
    197         bool inserted = addEdge(er, edges[j], graph); 
    198  
    199         graph[*er].id = j;//set id 
    200      
    201         if (HasReverseCost()) 
    202         { 
    203           graph[*er].cost = edges[j]->GetFieldAsDouble(RC_FEATURE);//set reverse cost 
    204         } 
    205         else  
    206         { 
    207           graph[*er].cost = edges[j]->GetFieldAsDouble(COST_FEATURE);//set cost 
    208         } 
    209  
    210       }  
    211  
    212       adjacent_edges.clear(); 
    213       rule_num = 0; 
    214     } 
    215     else 
    216     { 
    217       rule_num++; 
    218     }    
    219   } 
    220223 
    221224};