Changeset 049c2d3 in osmose-backend


Ignore:
Timestamp:
Jan 18, 2014 11:44:21 PM (6 years ago)
Author:
Jocelyn Jaubert <jocelyn.jaubert@…>
Branches:
master
Children:
81f8a35
Parents:
2463821
git-author:
Jocelyn Jaubert <jocelyn.jaubert@…> (18/01/2014 23:44:19)
git-committer:
Jocelyn Jaubert <jocelyn.jaubert@…> (18/01/2014 23:44:21)
Message:

Fix OsmSaxAlea? reader

There were case where the code didn't converge to the wanted element,
especially if this element had a lot of nodes or members.

Gzip files were also incorrectly handled, as b_max was set to the size of the
compressed file instead of the uncompressed file.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • modules/OsmSaxAlea.py

    r539f061 r049c2d3  
    3939def get_way_start(fd): 
    4040    b_min = 0 
    41     fd.seek(0, 2) 
    42     b_max = fd.tell() 
     41    b_max = get_file_last_line(fd) 
    4342    while True: 
    4443        b_cur = (b_min+b_max)/2 
     
    6766def get_relation_start(fd): 
    6867    b_min = 0 
    69     fd.seek(0, 2) 
    70     b_max = fd.tell() 
     68    b_max = get_file_last_line(fd) 
    7169    while True: 
    7270        b_cur = (b_min+b_max)/2 
     
    9593def get_node_id_start(fd, nodeid): 
    9694    b_min = 0 
    97     b_max = os.fstat(fd.fileno()).st_size 
    98     while True: 
    99         b_cur = (b_min+b_max)/2 
    100         fd.seek(b_cur) 
    101         fd.readline() 
    102         while True: 
    103             line = fd.readline().strip() 
     95    b_max = get_file_last_line(fd) 
     96    seq_read = False 
     97    prev_seq_read = False 
     98    while True: 
     99        if seq_read == True: 
     100            b_cur = b_min 
     101            prev_seq_read = True 
     102        else: 
     103            b_cur = (b_min+b_max)/2 
     104        fd.seek(b_cur) 
     105 
     106        while True: 
     107            line = fd.readline().strip() 
     108            line_len = len(line) 
    104109            if line.startswith("<node "): 
    105110                nid = int(ReGetId.findall(line)[0]) 
    106111                if nid < nodeid: 
    107                     b_min = b_cur 
     112                    if b_cur >= b_max: 
     113                        b_max *= 2 
     114                    b_min = b_cur + line_len 
    108115                    break 
    109116                if nid > nodeid: 
    110                     b_max = b_cur                     
     117                    if b_max == b_cur: 
     118                        # switch to sequential read if b_cur is in the middle 
     119                        # of the wanted element 
     120                        seq_read = True 
     121                    b_max = b_cur 
    111122                    break 
    112123                fd.seek(b_cur) 
    113                 b_cur += len(fd.readline()) 
    114124                while True: 
    115125                    line = fd.readline() 
     
    117127                        return b_cur 
    118128                    b_cur += len(line) 
    119             if line.startswith("<way "): 
    120                 b_max = b_cur 
    121                 break 
    122             if line.startswith("<relation "): 
    123                 b_max = b_cur 
    124                 break 
    125         if b_max - b_min <= 1: 
     129            if (line.startswith("<way ") or line.startswith("<relation ") or 
     130                     line.startswith("</osm>") or line_len == 0): 
     131                if b_max == b_cur: 
     132                    # switch to sequential read if b_cur is in the middle 
     133                    # of the wanted element 
     134                    seq_read = True 
     135                b_max = b_cur 
     136                break 
     137            b_cur += line_len 
     138        if b_max - b_min <= 1 or (prev_seq_read and b_cur == b_max): 
    126139            return None 
    127140 
    128141def get_way_id_start(fd, wayid): 
    129142    b_min = 0 
    130     b_max = os.fstat(fd.fileno()).st_size 
    131     while True: 
    132         b_cur = (b_min+b_max)/2 
    133         fd.seek(b_cur) 
    134         fd.readline() 
    135         while True: 
    136             line = fd.readline().strip() 
     143    b_max = get_file_last_line(fd) 
     144    seq_read = False 
     145    prev_seq_read = False 
     146    while True: 
     147        if seq_read == True: 
     148            b_cur = b_min 
     149            prev_seq_read = True 
     150        else: 
     151            b_cur = (b_min+b_max)/2 
     152        fd.seek(b_cur) 
     153        while True: 
     154            line = fd.readline().strip() 
     155            line_len = len(line) 
    137156            if line.startswith("<node "): 
    138                 b_min = b_cur 
     157                if b_cur >= b_max: 
     158                    b_max *= 2 
     159                b_min = b_cur + line_len 
    139160                break 
    140161            if line.startswith("<way "): 
    141162                wid = int(ReGetId.findall(line)[0]) 
    142163                if wid < wayid: 
    143                     b_min = b_cur 
     164                    if b_cur >= b_max: 
     165                        b_max *= 2 
     166                    b_min = b_cur + line_len 
    144167                    break 
    145168                if wid > wayid: 
    146                     b_max = b_cur                     
     169                    if b_max == b_cur: 
     170                        # switch to sequential read if b_cur is in the middle 
     171                        # of the wanted element 
     172                        seq_read = True 
     173                    b_max = b_cur 
    147174                    break 
    148175                fd.seek(b_cur) 
    149                 b_cur += len(fd.readline()) 
    150176                while True: 
    151177                    line = fd.readline() 
     
    153179                        return b_cur 
    154180                    b_cur += len(line) 
    155             if line.startswith("<relation "): 
    156                 b_max = b_cur 
    157                 break 
    158             if line.startswith("</osm>"): 
    159                 b_max = b_cur 
    160                 break; 
    161         if b_max - b_min <= 1: 
     181            if line.startswith("<relation ") or line.startswith("</osm>") or line_len == 0: 
     182                if b_max == b_cur: 
     183                    # switch to sequential read if b_cur is in the middle 
     184                    # of the wanted element 
     185                    seq_read = True 
     186                b_max = b_cur 
     187                break 
     188            b_cur += line_len 
     189        if b_max - b_min <= 1 or (prev_seq_read and b_cur == b_max): 
    162190            return None 
    163191 
    164192def get_relation_id_start(fd, relationid): 
    165193    b_min = 0 
    166     b_max = os.fstat(fd.fileno()).st_size 
    167     while True: 
    168         b_cur = (b_min+b_max)/2 
    169         fd.seek(b_cur) 
    170         fd.readline() 
    171         while True: 
    172             line = fd.readline().strip() 
    173             if line.startswith("<node "): 
    174                 b_min = b_cur 
    175                 break 
    176             if line.startswith("<way "): 
    177                 b_min = b_cur 
     194    b_max = get_file_last_line(fd) 
     195    seq_read = False 
     196    prev_seq_read = False 
     197    while True: 
     198        if seq_read == True: 
     199            b_cur = b_min 
     200            prev_seq_read = True 
     201        else: 
     202            b_cur = (b_min+b_max)/2 
     203        fd.seek(b_cur) 
     204        while True: 
     205            line = fd.readline().strip() 
     206            line_len = len(line) 
     207            if line.startswith("<node ") or line.startswith("<way "): 
     208                if b_cur >= b_max: 
     209                    b_max *= 2 
     210                b_min = b_cur + line_len 
    178211                break 
    179212            if line.startswith("<relation "): 
    180213                rid = int(ReGetId.findall(line)[0]) 
    181214                if rid < relationid: 
    182                     b_min = b_cur 
     215                    if b_cur >= b_max: 
     216                        b_max *= 2 
     217                    b_min = b_cur + line_len 
    183218                    break 
    184219                if rid > relationid: 
    185                     b_max = b_cur                     
     220                    if b_max == b_cur: 
     221                        # switch to sequential read if b_cur is in the middle 
     222                        # of the wanted element 
     223                        seq_read = True 
     224                    b_max = b_cur 
    186225                    break 
    187226                fd.seek(b_cur) 
    188                 b_cur += len(fd.readline()) 
    189227                while True: 
    190228                    line = fd.readline() 
     
    192230                        return b_cur 
    193231                    b_cur += len(line) 
    194         if b_max - b_min <= 1: 
     232            if line.startswith("</osm>") or line_len == 0: 
     233                if b_max == b_cur: 
     234                    # switch to sequential read if b_cur is in the middle 
     235                    # of the wanted element 
     236                    seq_read = True 
     237                b_max = b_cur 
     238                break; 
     239            b_cur += line_len 
     240        if b_max - b_min <= 1 or (prev_seq_read and b_cur == b_max): 
    195241            return None 
    196          
     242 
    197243def get_file_last_line(fd): 
    198     st = max(0, os.fstat(fd.fileno()).st_size - 512) 
    199     fd.seek(st) 
    200     while True: 
    201         line = fd.readline() 
    202         if line.strip().startswith("</osm>"): 
    203             return st 
    204         st += len(line) 
     244    return max(0, os.fstat(fd.fileno()).st_size) 
    205245 
    206246########################################################################### 
Note: See TracChangeset for help on using the changeset viewer.