Esempio n. 1
0
def convert_to_iclique_data_from_mesh_cloak():
    map_data = Map()
    map_data.read_map(option.MAP_PATH, option.MAP_FILE)

    f = open(option.QUERY_PATH + option.QUERY_FILE, "r")
    fstr = f.read()
    f.close()

    #
    f = open(option.QUERY_PATH + "iclique_" + option.QUERY_FILE, "w")
    timestamp = 0
    LARGE_STEP = 90  #60,90,120 seconds   : for separating time steps
    NUM_RANGES = 10  #5,10                : for sub-dividing in each time step
    SMALL_STEP = LARGE_STEP / NUM_RANGES  #ranges
    NUM_USERS = 5000
    REQUESTS_PER_RANGE = NUM_USERS / NUM_RANGES
    request_id = 0
    for line in fstr.split("\n"):
        if line == "":  # EOF
            break
        items = line.split("\t")

        ### 1 - FOR Brinkhoff generator
        #        # timestamp
        #        timestamp = int(items[4])
        #        if timestamp > 5:
        #            break
        #
        #        # area min (generated randomly from range 0.00005-0.0001)
        #        a_min_ratio = generate_a_min_ratio()
        #        a_min = map_data.area * a_min_ratio
        #
        #        #
        #        timestep = timestamp * LARGE_STEP + (request_id % NUM_USERS) / REQUESTS_PER_RANGE * SMALL_STEP
        #        f.write("%s\t%s\t%s\t%d\t%s\t%s\t%f"%(items[1],items[5],items[6],timestep,items[7],items[10],a_min))

        ### 2 - FOR TraceGenerator
        # timestamp
        timestamp = int(items[1])
        if timestamp > 5:
            break

        # area min (generated randomly from range 0.00005-0.0001)
        a_min_ratio = generate_a_min_ratio()
        a_min = map_data.area * a_min_ratio

        #
        timestep = timestamp * LARGE_STEP + (
            request_id % NUM_USERS) / REQUESTS_PER_RANGE * SMALL_STEP
        f.write("%s\t%s\t%s\t%d\t%s\t%s\t%f" %
                (items[0], items[2], items[3], timestep, items[4], items[7],
                 a_min))
        # (End) 2 - FOR TraceGenerator

        f.write("\n")
        request_id += 1

    f.close()
Esempio n. 2
0
def convert_to_iclique_data():
    map_data = Map()
    map_data.read_map(MAP_PATH, MAP_FILE)

    f = open(QUERY_PATH + QUERY_FILE, "r")
    fstr = f.read()
    f.close()

    #
    f = open(QUERY_PATH + "iclique_" + QUERY_FILE, "w")
    timestamp = 0
    for line in fstr.split("\n"):
        if line == "":  # EOF
            break
        items = line.split("\t")

        # timestamp
        timestamp = int(items[4])

        # area min (generated
        a_min_ratio = float(items[11])
        a_min = map_data.area * a_min_ratio

        ####
        #f.write("%s\t%s\t%s\t%s\t%s\t%s\t%f"%(items[1],items[5],items[6],items[4],items[7],items[10],a_min))

        f.write("%s\t%s\t%s\t%d\t%s\t%s\t%f" %
                (items[1], items[5], items[6], timestamp * 60, items[7],
                 items[10], a_min))

        #f.write("%s\t%s\t%s\t%d\t%s\t%s\t%f"%(items[1],items[5],items[6],timestamp,items[7],items[10],a_min))
        #timestamp += 1

        f.write("\n")

    f.close()
Esempio n. 3
0
            
   
#######################################################
#    MAIN (test)
#######################################################
if __name__ == "__main__":
    
    
#    mc_set_1 = [set([1,2,3]), set([1,3,4])]
#    mc_set_2 = [set([1,5,6]), set([1,4,5]), set([1,3,4])]
#    
#    Graph.intersect_mc_set(mc_set_1, mc_set_2)
        
    start_time = time.clock()
        
    map_data = Map()
    map_data.read_map(option.MAP_PATH, option.MAP_FILE)
    print "Load Map : DONE"
    query_log = QueryLog(map_data)
    query_log.read_query(option.QUERY_PATH, option.QUERY_FILE, max_time_stamp = 10)    
    print "Load Query : DONE"
    
    print "max_speed = ", query_log.max_speed
    print "elapsed : ", (time.clock() - start_time)   
    
        
    graph = Graph(0, map_data, query_log, None)
    
    graph.init_mc_set()
    
    #TEST
Esempio n. 4
0
        timestep = int(sys.argv[2])
        option.DISTANCE_CONSTRAINT = int(sys.argv[3])

    if len(sys.argv) > 4:
        option.K_GLOBAL = int(sys.argv[4])

    if len(sys.argv) > 5:
        option.INIT_COVER_KEEP_RATIO = float(sys.argv[5])

    if len(sys.argv) > 6:
        option.NEXT_COVER_KEEP_RATIO = float(sys.argv[6])

    #
    start_time = time.clock()

    map_data = Map()
    map_data.read_map(option.MAP_PATH, option.MAP_FILE)
    print "Load Map : DONE"
    query_log = QueryLog(map_data)
    query_log.read_query(
        option.QUERY_PATH, option.QUERY_FILE, max_time_stamp=40
    )  # default: max_time_stamp = 10 (40: only for attack)
    print "Load Query : DONE"

    print "max_speed = ", query_log.max_speed
    print "elapsed : ", (time.clock() - start_time)

    graph = Graph(0, map_data, query_log, None)

    #TEST
    graph.run_timestamps(0, timestep)
Esempio n. 5
0
#     ac_events[0].append(2)
#     ac_events[0].append(3)
#     ac_events[3].append([1,4,3])
#     print ac_events
    
    # TEST Map.compute_fixed_expanding(), EdgeSegmentSet.clean_fixed_expanding()
    timestep = 3
    print "MAP_FILE =", option.MAP_FILE
    print "timestep =", timestep
    print "QUERY_FILE =", option.QUERY_FILE
    print "DISTANCE_CONSTRAINT =", option.DISTANCE_CONSTRAINT
     
    #    
    start_time = time.clock()
         
    map_data = Map()
    map_data.read_map(option.MAP_PATH, option.MAP_FILE)
    print "Load Map : DONE"
    query_log = QueryLog(map_data)
    query_log.read_query(option.QUERY_PATH, option.QUERY_FILE, timestep, option.QUERY_TYPE)   # default: max_time_stamp = 10 (40: only for attack) 
    print "Load Query : DONE"
     
    print "max_speed = ", query_log.max_speed
    print "elapsed : ", (time.clock() - start_time)  
    
    #
    timestamp = 0;
    expanding_list = {}                                 #dict of lists
    query_list = query_log.frames[timestamp]       # timestamp
    
    
                    full_edge_meshes[e.cur_edge_id] = []
                full_edge_meshes[e.cur_edge_id].append(obj_id)
                    
            else:                                       #PARTIAL edge
                part_edges.append((e, obj_id))          # "list" of only one point mesh(obj_id) covers e

    return full_edge_meshes, part_edges

#######################################################
#    MAIN (test)
#######################################################
if __name__ == "__main__":
    
    start_time = time.clock()
        
    map_data = Map()
    map_data.read_map(option.MAP_PATH, option.MAP_FILE)
    print "Load Map : DONE"
    query_log = QueryLog(map_data)
    query_log.read_query(option.QUERY_PATH, option.QUERY_FILE, max_time_stamp = 5)    
    print "Load Query : DONE"
    
    print "max_speed = ", query_log.max_speed
    print "elapsed : ", (time.clock() - start_time)   
    
    graph = Graph(0, map_data, query_log, None)
    
    #
    timestamp = 0
    if len(sys.argv) > 1:
        timestamp = int(sys.argv[1])
        seg_list = edge_segment_set.clean_fixed_expanding(seg_list)
        result.append(seg_list)
    
    return result   




#######################################################
#    MAIN (test)
#######################################################
if __name__ == "__main__":
    
    start_time = time.clock()
        
    map_data = Map()
    map_data.read_map(option.MAP_PATH, option.MAP_FILE)
    print "Load Map : DONE"
    query_log = QueryLog(map_data)
    query_log.read_query(option.QUERY_PATH, option.QUERY_FILE, max_time_stamp = 5)    
    print "Load Query : DONE"
    
    print "max_speed = ", query_log.max_speed
    print "elapsed : ", (time.clock() - start_time)   
    
    print "size(map_data) =", sys.getsizeof(map_data)
    
    #
    expanding_list_1 = {}                                 #dict of lists
    
    timestamp = 0
Esempio n. 8
0
                                                    query.cur_edge_id,
                                                    init_graph_distance)
        seg_list = edge_segment_set.clean_fixed_expanding(seg_list)
        result.append(seg_list)

    return result


#######################################################
#    MAIN (test)
#######################################################
if __name__ == "__main__":

    start_time = time.clock()

    map_data = Map()
    map_data.read_map(option.MAP_PATH, option.MAP_FILE)
    print "Load Map : DONE"
    query_log = QueryLog(map_data)
    query_log.read_query(option.QUERY_PATH,
                         option.QUERY_FILE,
                         max_time_stamp=5)
    print "Load Query : DONE"

    print "max_speed = ", query_log.max_speed
    print "elapsed : ", (time.clock() - start_time)

    print "size(map_data) =", sys.getsizeof(map_data)

    #
    expanding_list_1 = {}  #dict of lists
Esempio n. 9
0
                                self.height - end_y,
                                fill=color)

    #######################################################
    def draw_rectangle(self, x1, y1, x2, y2, color):
        self.draw_line(x1, y1, x1, y2, color)
        self.draw_line(x2, y1, x2, y2, color)
        self.draw_line(x1, y1, x2, y1, color)
        self.draw_line(x1, y2, x2, y2, color)


#######################################################
#    MAIN (test)
#######################################################
if __name__ == "__main__":
    map_data = Map()
    map_data.read_map(
        "D:/Documents/Paper-code/Network-based-Generator-of-Moving-Objects/DataFiles/",
        "oldenburgGen")

    query_log = QueryLog(map_data)
    query_log.read_query(
        "D:/Documents/Paper-code/Network-based-Generator-of-Moving-Objects/DataFiles/oldenburgGen/",
        "oldenburgGen.txt")

    #
    master = Tk()

    width = 700
    map_visualizer = MapVisualizer(map_data, query_log, width)
Esempio n. 10
0
                
                
    #######################################################    
    def draw_rectangle(self, x1, y1, x2, y2, color):
        self.draw_line(x1, y1, x1, y2, color)
        self.draw_line(x2, y1, x2, y2, color)
        self.draw_line(x1, y1, x2, y1, color)
        self.draw_line(x1, y2, x2, y2, color)
         


#######################################################
#    MAIN (test)
#######################################################
if __name__ == "__main__":            
    map_data = Map()
    map_data.read_map("D:/Documents/Paper-code/Network-based-Generator-of-Moving-Objects/DataFiles/", 
                 "oldenburgGen")
    
    query_log = QueryLog(map_data)
    query_log.read_query("D:/Documents/Paper-code/Network-based-Generator-of-Moving-Objects/DataFiles/oldenburgGen/",
                         "oldenburgGen.txt")
    
    #
    master = Tk()
   
    
    width = 700
    map_visualizer = MapVisualizer(map_data, query_log, width)