コード例 #1
0
def main():
    params = parameters.Parameters()
    params.read(sys.argv[1:])
    sim = False

    for task in params.task:
        if task == "app":
            dash_ui.launcher.launch_app(params)

        elif task == "help":
            if (len(sys.argv) > 2):
                params.help(sys.argv[2])
            else:
                params.help()

        elif task == "track":
            tracking.track(params)

        elif task == "simulate":
            simulation.simulate(params)
            sim = True

        elif task == "postprocess":
            postprocessing.postprocess(params, simulated=sim)

        elif task == "view":
            visualisation.render(params)

        elif task == "compare":
            trajectories.compare_trajectories(params)

        else:
            sys.exit(f"ERROR: Task {task} is not yet implemented. Aborting...")
コード例 #2
0
def movie_menu(title, imdb_id):
    tracking.track('/Movies/Movie', { 'Title': title })

    torrent_infos = []
    
    torrent_provider = SharedCodeService.metaprovider.MetaProvider()
    torrent_provider.movies_get_specific_torrents(imdb_id, torrent_infos)

    torrent_infos.sort(key=lambda torrent_info: torrent_info.seeders, reverse=True)

    object_container = ObjectContainer(title2=title)
    
    for torrent_info in torrent_infos:
        seeders_leechers_line = '{0}\nSeeders: {1}, Leechers: {2}'.format(torrent_info.size, torrent_info.seeders, torrent_info.leechers)

        movie_object = MovieObject()

        SharedCodeService.trakt.movies_fill_movie_object(movie_object, imdb_id)
        object_container.title2 = movie_object.title

        movie_object.title    = torrent_info.release
        movie_object.summary  = '{0}\n\n{1}'.format(seeders_leechers_line, movie_object.summary) 
        movie_object.url      = torrent_info.url

        object_container.add(movie_object)

    return object_container
コード例 #3
0
def menu():
    tracking.track('/Anime')

    object_container = ObjectContainer(title2='Anime')
    object_container.add(DirectoryObject(key=Callback(popular_menu, title='Popular', per_page=31), title='Popular', summary='Browse popular anime'))
    object_container.add(InputDirectoryObject(key=Callback(search_menu, title='Search', per_page=31), title='Search', summary='Search anime', thumb=R('search.png'), prompt='Search for anime'))
    return object_container
コード例 #4
0
    def test_track_multiple_t1_swaps_special_example_7(self):

        sys.setrecursionlimit(40000)
 
        first_mesh = mesh.load(path.join(dirname(__file__), 'data', 'multiple_t1_example_7_before.mesh'))
        second_mesh = mesh.load(path.join(dirname(__file__), 'data', 'multiple_t1_example_7_after.mesh'))
         
        # build ground truth for testing the mapping
        ground_truth = {}
        for element_index, element in enumerate(first_mesh.elements):
            ground_truth[element.id_in_frame] = second_mesh.elements[element_index].id_in_frame
         
        first_mesh.plot(path.join(dirname(__file__),'output','multiple_t1_example_7_before.pdf'))
        second_mesh.plot(path.join(dirname(__file__),'output','multiple_t1_example_7_after.pdf'))
 
        tracking.track(first_mesh, second_mesh)
#         tracking.find_maximum_common_subgraph(first_mesh, second_mesh)
     
        first_mesh.plot(path.join(dirname(__file__),'output','multiple_t1_example_7_before.pdf'), 
                        color_by_global_id = True, total_number_of_global_ids = first_mesh.get_num_elements())
        second_mesh.plot(path.join(dirname(__file__),'output','multiple_t1_example_7_after.pdf'),
                        color_by_global_id = True, total_number_of_global_ids = first_mesh.get_num_elements())
         
        print 'evaluate tracking'
        tracking_success, number_tracked_cells = tracking.evaluate_tracking(first_mesh, 
                                                                   second_mesh, 
                                                                   ground_truth)
コード例 #5
0
def episode_menu(show_title, tvdb_id, season_index, episode_index, first_aired_iso):
    tracking.track('/TV Shows/Episode', { 'Title': show_title, 'Season': season_index, 'Episode': episode_index })

    torrent_provider = SharedCodeService.metaprovider.MetaProvider()
    torrent_infos    = []
    torrent_provider.tvshows_get_specific_torrents(tvdb_id, season_index, episode_index, first_aired_iso, torrent_infos)

    torrent_infos.sort(key=lambda torrent_info: torrent_info.seeders, reverse=True)

    object_container = ObjectContainer()
    
    for torrent_info in torrent_infos:
        seeders_leechers_line = '{0}\nSeeders: {1}, Leechers: {2}'.format(torrent_info.size, torrent_info.seeders, torrent_info.leechers)

        episode_object = EpisodeObject()

        SharedCodeService.trakt.tvshows_fill_episode_object(episode_object, tvdb_id, season_index, episode_index)
        object_container.title2 = episode_object.title

        episode_object.title    = torrent_info.release
        episode_object.summary  = '{0}\n\n{1}'.format(seeders_leechers_line, episode_object.summary)
        episode_object.url      = torrent_info.url

        object_container.add(episode_object)

    return object_container
コード例 #6
0
def movie_menu(title, imdb_id):
    tracking.track('/Movies/Movie', {'Title': title})

    torrent_infos = []

    torrent_provider = SharedCodeService.metaprovider.MetaProvider()
    torrent_provider.movies_get_specific_torrents(imdb_id, torrent_infos)

    torrent_infos.sort(key=lambda torrent_info: torrent_info.seeders,
                       reverse=True)

    object_container = ObjectContainer(title2=title)

    for torrent_info in torrent_infos:
        seeders_leechers_line = '{0}\nSeeders: {1}, Leechers: {2}'.format(
            torrent_info.size, torrent_info.seeders, torrent_info.leechers)

        movie_object = MovieObject()

        SharedCodeService.trakt.movies_fill_movie_object(movie_object, imdb_id)
        object_container.title2 = movie_object.title

        movie_object.title = torrent_info.release
        movie_object.summary = '{0}\n\n{1}'.format(seeders_leechers_line,
                                                   movie_object.summary)
        movie_object.url = torrent_info.url

        object_container.add(movie_object)

    return object_container
コード例 #7
0
def favorites_menu(title):
    tracking.track('/TV Shows/' + title)

    ids = Dict['tvshows_favorites'] if 'tvshows_favorites' in Dict else []

    object_container = ObjectContainer(title2=title)
    fill_object_container(object_container, ids)
    return object_container
コード例 #8
0
def about_menu():
    tracking.track('/About')

    object_container = ObjectContainer(title2='About')
    object_container.add(DirectoryObject(key=Callback(empty_menu), title='Channel version: {0}'.format(SharedCodeService.common.VERSION), summary='Current version of the BitTorrent channel'))
    object_container.add(DirectoryObject(key=Callback(empty_menu), title='Local IP: {0}'.format(Network.Address), summary='Plex Media Server Local IP'))
    object_container.add(DirectoryObject(key=Callback(empty_menu), title='Public IP: {0}'.format(Network.PublicAddress), summary='Plex Media Server Public IP'))
    return object_container
コード例 #9
0
def run_tracking_task(nclicks, active_file, params_json):
    params = Parameters(json.loads(params_json))
    params._params = json.loads(params_json)
    if ".tif" in active_file:
        params.name = active_file.replace('.tif','')

    tracking.track(params)

    return ["", 1, True, 'render-current-trajectories']
コード例 #10
0
    def onChange(self, trackbarValue):
        #set video to starting frame
        self.video.set(cv2.CAP_PROP_POS_FRAMES, self.start)
        cnts, image_edged3, image_contours = imagePros(self.fileName,
                                                       option='vid')

        cells = []
        bboxes = []
        global x
        global y
        global w
        global h
        global counter
        counter = 0
        cellTags = []
        #Ignore contours that do not satisfy size criteria
        for i in cnts:
            if cv2.contourArea(i) < 700 or cv2.contourArea(i) > 6000:
                continue
            hull = cv2.convexHull(i)
            cv2.drawContours(image_contours, [hull], 0, (34, 255, 34), 2)
            x, y, w, h = cv2.boundingRect(i)
            #save coordinates in bboxes array
            bboxes.append([x, y, w, h])

            M = cv2.moments(i)
            cx = int(M['m10'] / M['m00'])
            cy = int(M['m01'] / M['m00'])
            #save centers in cells array
            cells.append([cx, cy])
            cellLet = chr(counter + 67)
            cellTags.append(counter + 67)
            cv2.putText(image_contours, cellLet, (cx, cy),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (225, 0, 255), 2)
            counter = counter + 1

        cv2.putText(image_contours, "cell count: " + str(counter), (10, 40),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 255), 2)

        #show starting video frame with each cell tagged
        cv2.imshow("cellVid", image_contours)
        k = cv2.waitKey()
        print(cellTags)
        print(k)
        if k == 27:
            pass
        elif k in cellTags:
            #selected cell's coordinates are sent to tracking
            print("key")
            cellnumber = k - 67
            print(len(bboxes))
            print(cellnumber)
            tracking.track(bboxes[cellnumber][0], bboxes[cellnumber][1],
                           bboxes[cellnumber][2], bboxes[cellnumber][3],
                           cv2.CAP_PROP_POS_FRAMES, self.fileName)

        pass
コード例 #11
0
def menu():
    tracking.track('/Movies')

    object_container = ObjectContainer(title2='Movies')
    object_container.add(DirectoryObject(key=Callback(movies_menu, title='Popular', page='/movies/trending', per_page=31), title='Popular', summary='Browse popular movies'))
    object_container.add(DirectoryObject(key=Callback(movies_menu, title='Rating', page='/movies/popular', per_page=31), title='Rating', summary='Browse highly-rated movies'))
    object_container.add(DirectoryObject(key=Callback(genres_menu, title='Genres'), title='Genres', summary='Browse movies by genre'))
    object_container.add(InputDirectoryObject(key=Callback(search_menu, title='Search', per_page=31), title='Search', summary='Search movies', thumb=R('search.png'), prompt='Search for movies'))
    return object_container
コード例 #12
0
def genres_menu(title):
    tracking.track('/Movies/' + title)

    genres = SharedCodeService.trakt.movies_genres()

    object_container = ObjectContainer(title2=title)
    for genre in genres:
        object_container.add(DirectoryObject(key=Callback(genre_menu, title=genre[0], genre=genre[1], per_page=31), title=genre[0]))
    return object_container
コード例 #13
0
def search_menu(title, query, per_page, count=0):
    tracking.track('/Movies/Search', { 'Query': query })

    ids   = []
    count = SharedCodeService.trakt.movies_search(query, ids)

    object_container = ObjectContainer(title2=title)
    fill_object_container(object_container, ids)
    return object_container
コード例 #14
0
def menu():
    tracking.track('/TV Shows')

    object_container = ObjectContainer(title2='TV Shows')
    object_container.add(DirectoryObject(key=Callback(shows_menu, title='Popular', page='/shows/trending', per_page=31), title='Popular', summary='Browse popular TV shows'))
    object_container.add(DirectoryObject(key=Callback(shows_menu, title='Rating', page='/shows/popular', per_page=31), title='Rating', summary='Browse highly-rated TV shows'))
    object_container.add(DirectoryObject(key=Callback(genres_menu, title='Genres'), title='Genres', summary='Browse TV shows by genre'))
    object_container.add(DirectoryObject(key=Callback(favorites_menu, title='Favorites'), title='Favorites', summary='Browse your favorite TV shows', thumb=R('favorites.png')))
    object_container.add(InputDirectoryObject(key=Callback(search_menu, title='Search', per_page=31), title='Search', summary='Search TV shows', thumb=R('search.png'), prompt='Search for TV shows'))    
    return object_container
コード例 #15
0
def remove_from_favorites(title, show_title, tvdb_id):
    tracking.track('/TV Shows/FavRemove', { 'Title': show_title })

    if 'tvshows_favorites' in Dict and tvdb_id in Dict['tvshows_favorites']:
        Dict['tvshows_favorites'].remove(tvdb_id)
        Dict.Save()

    object_container = ObjectContainer(title2=title)
    object_container.header  = 'Remove from Favorites'
    object_container.message = '{0} removed from Favorites'.format(show_title)
    return object_container
コード例 #16
0
def genre_menu(title, genre, per_page, count=0):
    tracking.track('/Movies/Genre', { 'Genre': title })

    ids   = []
    count = SharedCodeService.trakt.get_ids_from_page('/movies/popular/' + genre, ids, count, per_page)

    object_container = ObjectContainer(title2=title)
    fill_object_container(object_container, ids)
    object_container.add(NextPageObject(key=Callback(genre_menu, title=title, genre=genre, per_page=per_page, count=count), title="More..."))
    
    return object_container
コード例 #17
0
def movies_menu(title, page, per_page, count=0):
    tracking.track('/Movies/' + title)

    ids   = []
    count = SharedCodeService.trakt.get_ids_from_page(page, ids, count, per_page)

    object_container = ObjectContainer(title2=title)
    fill_object_container(object_container, ids)
    object_container.add(NextPageObject(key=Callback(movies_menu, title=title, page=page, per_page=per_page, count=count), title="More..."))
    
    return object_container
コード例 #18
0
ファイル: main.py プロジェクト: meexwaal/MarkOffProcessor
def main():
    cap = cv2.VideoCapture(1)

    # mask
    while (True):
        ret, frame = cap.read()
        if frame is None:
            #print("frame is None")
            continue
        img = processImage(frame)
        cv2.imshow('Image', img)
        key = cv2.waitKey(1) & 0xFF
        if doneBuilding():
            if key == ord('m'):
                toggleMask(img)
            if key == ord('p'):
                break

    print("made mask")
    print("searching for bot...")

    # plan
    botLoc = None
    while (botLoc is None):
        ret, frame = cap.read()
        botLoc = tracking.track(frame)

    print("found bot at", botLoc)
    print("initializing bot...")
    bot = robot(botLoc)
    print("initialized bot!")

    print("finding path...")
    ret, frame = cap.read()
    img = processImage(frame)
    path = findPath(img, botLoc)
    print("found it")

    bot.followLine(path)

    # move
    while (True):
        ret, frame = cap.read()

        img = processImage(frame)

        botLoc = tracking.track(frame)
        # print("bot location:", botLoc)

        if botLoc == (None, None):
            continue

        bot.update(botLoc)
コード例 #19
0
def season_menu(title, show_title, tvdb_id, season_index):
    tracking.track('/TV Shows/Season', { 'Title': show_title, 'Season': season_index })

    object_container = ObjectContainer(title2=title)
    for episode_index in SharedCodeService.trakt.tvshows_get_season_episode_index_list(tvdb_id, season_index):
        directory_object = DirectoryObject()
        episode_data = SharedCodeService.trakt.tvshows_fill_episode_object(directory_object, tvdb_id, season_index, episode_index)
        directory_object.title = str(episode_index) + '. ' + directory_object.title
        directory_object.key  = Callback(episode_menu, show_title=show_title, tvdb_id=tvdb_id, season_index=season_index, episode_index=episode_index, first_aired_iso=episode_data['first_aired_iso'])
        object_container.add(directory_object)

    return object_container
コード例 #20
0
def add_to_favorites(title, show_title, tvdb_id):
    tracking.track('/TV Shows/FavAdd', { 'Title': show_title })

    if 'tvshows_favorites' not in Dict:
        Dict['tvshows_favorites'] = []

    if tvdb_id not in Dict['tvshows_favorites']:
        Dict['tvshows_favorites'].append(tvdb_id)
        Dict.Save()

    object_container = ObjectContainer(title2=title)
    object_container.header  = 'Add to Favorites'
    object_container.message = '{0} added to Favorites'.format(show_title)
    return object_container
コード例 #21
0
    def test_plot_collection_into_separate_figure(self):
        """plot a polygon collection into a figure designed by us 
        """
        sys.setrecursionlimit(40000)
        mesh_one = mesh.creation.generate_random_tesselation(5, 5)

        print 'start to copy'
        mesh_two = copy.deepcopy(mesh_one)
        print 'stop to copy'

        mesh_one.assign_frame_ids_in_order()
        mesh_two.assign_frame_ids_randomly()

        tracked_ids = tracking.track(mesh_one, mesh_two)

        # figure properties
        figuresize = (4, 2.75)
        font = {'size': 10}
        plt.rc('font', **font)

        mesh_figure = plt.figure(figsize=figuresize)

        ax = plt.axes([0, 0, 1, 1])
        polygon_collection = mesh_two.get_polygon_collection(
            color_by_global_id=True,
            total_number_of_global_ids=mesh_one.get_num_elements())
        mesh_figure.gca().add_collection(polygon_collection)
        mesh_figure.gca().set_aspect('equal')
        mesh_figure.gca().autoscale_view()
        plt.axis('off')
        filename = path.join(dirname(__file__), 'output',
                             'own_visualisation_figure.pdf')
        mesh_figure.savefig(filename, bbox_inches='tight')
コード例 #22
0
def make_permutation_plot(figuresize):
    mesh_one = mesh.creation.generate_random_tesselation(9,9)
    mesh_two = copy.deepcopy(mesh_one)

    mesh_one.assign_frame_ids_in_order()
    mesh_two.assign_frame_ids_randomly()

    # build ground truth for testing the mapping
    ground_truth = {}
    for element_index, element in enumerate(mesh_one.elements):
        ground_truth[element.id_in_frame] = mesh_two.elements[element_index].id_in_frame

    tracked_ids = tracking.find_maximum_common_subgraph( mesh_one, mesh_two )
    
    for element in mesh_one.elements:
        element.global_id = None
  
    for element in mesh_two.elements:
        element.global_id = None
 
    tracked_ids_all = tracking.track(mesh_one, mesh_two)        

    plotname = 'permutation'

    make_difference_plot(mesh_one, mesh_two, tracked_ids, tracked_ids_all, plotname, figuresize)
コード例 #23
0
def make_general_division_plot(figuresize):
    """We load a mesh where two maximum common subgraphs will be identified, and track the division event"""

    mesh_one = mesh.creation.generate_random_tesselation(9,9)
    mesh_two = copy.deepcopy(mesh_one)

    mesh_one.assign_frame_ids_in_order()
    mesh_two.assign_frame_ids_randomly()

    # build ground truth for testing the mapping
    ground_truth = {}
    for element_index, element in enumerate(mesh_one.elements):
        ground_truth[element.id_in_frame] = mesh_two.elements[element_index].id_in_frame

    # pick the element closest to the centre
    most_central_element = mesh_two.find_most_central_element()
            
    mesh_two.divide_element_with_frame_id_in_direction(most_central_element.id_in_frame, [1.0, 1.0])
     
    tracked_ids = tracking.find_maximum_common_subgraph( mesh_one, mesh_two )
    
    for element in mesh_one.elements:
        element.global_id = None
  
    for element in mesh_two.elements:
        element.global_id = None
 
    tracked_ids_all = tracking.track(mesh_one, mesh_two)        

    plotname = 'division_general'

    make_difference_plot(mesh_one, mesh_two, tracked_ids, tracked_ids_all, plotname, figuresize)
コード例 #24
0
def make_death_plots(figuresize):
    mesh_one = mesh.creation.generate_random_tesselation(9, 9)
    mesh_two = copy.deepcopy(mesh_one)

    # First pick a cell in the centre
    mesh_centre = mesh_two.calculate_centre()

    mesh_one.assign_frame_ids_in_order()
    mesh_two.assign_frame_ids_randomly()

    most_central_element = mesh_two.find_most_central_element()

    mesh_two.kill_element_with_frame_id(most_central_element.id_in_frame)

    tracked_ids = tracking.find_maximum_common_subgraph(mesh_one, mesh_two)

    for element in mesh_one.elements:
        element.global_id = None

    for element in mesh_two.elements:
        element.global_id = None

    tracked_ids_all = tracking.track(mesh_one, mesh_two)

    plotname = 'cell_death'

    make_difference_plot(mesh_one, mesh_two, tracked_ids, tracked_ids_all,
                         plotname, figuresize)
コード例 #25
0
def make_death_plots(figuresize):
    mesh_one = mesh.creation.generate_random_tesselation(9,9)
    mesh_two = copy.deepcopy(mesh_one)

    # First pick a cell in the centre
    mesh_centre = mesh_two.calculate_centre()
        
    mesh_one.assign_frame_ids_in_order()
    mesh_two.assign_frame_ids_randomly()

    most_central_element = mesh_two.find_most_central_element()
               
    mesh_two.kill_element_with_frame_id(most_central_element.id_in_frame)

    tracked_ids = tracking.find_maximum_common_subgraph( mesh_one, mesh_two )

    for element in mesh_one.elements:
        element.global_id = None
  
    for element in mesh_two.elements:
        element.global_id = None
  
    tracked_ids_all = tracking.track( mesh_one, mesh_two )
    
    plotname = 'cell_death'
    
    make_difference_plot(mesh_one, mesh_two, tracked_ids, tracked_ids_all, plotname, figuresize)
コード例 #26
0
def make_permutation_plot(figuresize):
    mesh_one = mesh.creation.generate_random_tesselation(9, 9)
    mesh_two = copy.deepcopy(mesh_one)

    mesh_one.assign_frame_ids_in_order()
    mesh_two.assign_frame_ids_randomly()

    # build ground truth for testing the mapping
    ground_truth = {}
    for element_index, element in enumerate(mesh_one.elements):
        ground_truth[
            element.id_in_frame] = mesh_two.elements[element_index].id_in_frame

    tracked_ids = tracking.find_maximum_common_subgraph(mesh_one, mesh_two)

    for element in mesh_one.elements:
        element.global_id = None

    for element in mesh_two.elements:
        element.global_id = None

    tracked_ids_all = tracking.track(mesh_one, mesh_two)

    plotname = 'permutation'

    make_difference_plot(mesh_one, mesh_two, tracked_ids, tracked_ids_all,
                         plotname, figuresize)
コード例 #27
0
def make_general_division_plot(figuresize):
    """We load a mesh where two maximum common subgraphs will be identified, and track the division event"""

    mesh_one = mesh.creation.generate_random_tesselation(9, 9)
    mesh_two = copy.deepcopy(mesh_one)

    mesh_one.assign_frame_ids_in_order()
    mesh_two.assign_frame_ids_randomly()

    # build ground truth for testing the mapping
    ground_truth = {}
    for element_index, element in enumerate(mesh_one.elements):
        ground_truth[
            element.id_in_frame] = mesh_two.elements[element_index].id_in_frame

    # pick the element closest to the centre
    most_central_element = mesh_two.find_most_central_element()

    mesh_two.divide_element_with_frame_id_in_direction(
        most_central_element.id_in_frame, [1.0, 1.0])

    tracked_ids = tracking.find_maximum_common_subgraph(mesh_one, mesh_two)

    for element in mesh_one.elements:
        element.global_id = None

    for element in mesh_two.elements:
        element.global_id = None

    tracked_ids_all = tracking.track(mesh_one, mesh_two)

    plotname = 'division_general'

    make_difference_plot(mesh_one, mesh_two, tracked_ids, tracked_ids_all,
                         plotname, figuresize)
コード例 #28
0
def runme(input_vid_path, background_image_path, s_initial):

    # 1 - stabilize the input vid
    stabilized_vid = st.stabilize(input_vid_path)

    # 2 - subtract background from stabilized video
    print("Starting trimap")
    trimap_folder, trimap_vid = tri.trimap(stabilized_vid)
    print("Done with trimap")

    # 3 - apply matting
    print("Starting matting")
    matted_vid = mt.add_background_image(trimap_folder, stabilized_vid,
                                         background_image_path)
    print("Done with matting")

    # generate frames folder
    ut.save_video_frames(matted_vid, folder_name="matted_vid_4_frames")

    # 4 - apply tracking
    print("Starting tracking")
    output_vid = tr.track("matted_vid_4_frames", s_initial)

    # 5 - generate the output video from the tracked frames
    ut.create_video_from_image_folder("tracked_images",
                                      "OUTPUT.avi",
                                      shape=(555, 416))
    print("Done tracking")

    return output_vid
コード例 #29
0
    def test_plot_collection_into_separate_figure(self):
        """plot a polygon collection into a figure designed by us 
        """
        sys.setrecursionlimit(40000)
        mesh_one = mesh.creation.generate_random_tesselation(5,5)
       
        print 'start to copy'
        mesh_two = copy.deepcopy(mesh_one)
        print 'stop to copy'
         
        mesh_one.assign_frame_ids_in_order()
        mesh_two.assign_frame_ids_randomly()

        tracked_ids = tracking.track(mesh_one, mesh_two)

        # figure properties
        figuresize = (4,2.75)
        font = {'size'   : 10}
        plt.rc('font', **font)

        mesh_figure = plt.figure(figsize = figuresize)

        ax = plt.axes([0,0,1,1])
        polygon_collection = mesh_two.get_polygon_collection(color_by_global_id = True,
                                           total_number_of_global_ids = mesh_one.get_num_elements())
        mesh_figure.gca().add_collection(polygon_collection)
        mesh_figure.gca().set_aspect('equal')
        mesh_figure.gca().autoscale_view()
        plt.axis('off')
        filename = path.join(dirname(__file__),'output','own_visualisation_figure.pdf')
        mesh_figure.savefig(filename, bbox_inches = 'tight')
コード例 #30
0
def main(model=Model.DECISION_TREE, seed=None):
    original_train, original_validate = load_data()
    train, validate = encode(original_train, original_validate)
    with tracking.track() as track:
        track.set_model(model)
        model, params = train_model(train, model, seed)
        track.log_params(params)
        validation_predictions = make_predictions(model, validate)

        print("Calculating metrics")
        evaluation_metrics = {
            'nwrmsle':
            evaluation.nwrmsle(validation_predictions,
                               validate['unit_sales'].values,
                               validate['perishable'].values),
            'r2_score':
            metrics.r2_score(y_true=validate['unit_sales'].values,
                             y_pred=validation_predictions)
        }
        track.log_metrics(evaluation_metrics)

        write_predictions_and_score(evaluation_metrics, model,
                                    original_train.columns)

        print("Evaluation done with metrics {}.".format(
            json.dumps(evaluation_metrics)))
コード例 #31
0
   def xest_track_shuffled_2_by_2_mesh(self):
       """ This tests whether we can identify cells after they got shuffled (2 by 2)
           This test is known to fail: due to the symmetry of the problem cells tend to
           be mapped in the wrong order.
       """
       mesh_one = mesh.creation.generate_hexagonal(2,2)
       mesh_two = mesh.creation.generate_hexagonal(2,2)
         
       mesh_one.assign_frame_ids_in_order()
         
       mesh_two.assign_frame_ids_in_reverse_order()
 
       id_map = tracking.track(mesh_one, mesh_two)
         
       network_one = mesh_one.generate_network()
       network_two = mesh_two.generate_network()
 
       subgraph_network = tracking.generate_subgraph_network(mesh_two, id_map)
 
       self.assertEqual(len(id_map), 4)
 
       for index_one in id_map:
           element_one = mesh_one.get_element_with_frame_id(index_one)
           element_two = mesh_two.get_element_with_global_id(id_map[index_one])
           self.assertEqual(element_one.get_num_nodes(), element_two.get_num_nodes())
           self.assertEqual(network_one.degree(index_one), network_two.degree(id_map[index_one]))
           self.assertAlmostEqual(element_one.calculate_area(), element_two.calculate_area())
           np.testing.assert_almost_equal(element_one.calculate_centroid(), element_two.calculate_centroid())
コード例 #32
0
   def xest_track_shuffled_3_by_3_mesh(self):
       """ This tests whether we can identify cells after they got shuffled (3 by 3)
       """
       mesh_one = mesh.creation.generate_hexagonal(3,3)
       mesh_two = mesh.creation.generate_hexagonal(3,3)
  
       mesh_one.assign_frame_ids_in_order()
       mesh_one.plot(path.join(dirname(__file__),'output','mesh_one.pdf'))
         
       mesh_two.assign_frame_ids_randomly()
 
       mesh_two.plot(path.join(dirname(__file__),'output','mesh_two_before_tracking.pdf'))
 
       tracked_ids = tracking.track(mesh_one, mesh_two)
     
       mesh_two.plot(path.join(dirname(__file__),'output','mesh_two_after_tracking.pdf'), color_by_global_id = True, total_number_of_global_ids = 9)
 
       network_one = mesh_one.generate_network()
       network_two = mesh_two.generate_network()
 
       subgraph_network = tracking.generate_subgraph_network(mesh_two, tracked_ids)
 
       self.assertEqual(len(tracked_ids), 9)
 
       for global_id in tracked_ids:
           element_one = mesh_one.get_element_with_frame_id(global_id)
           element_two = mesh_two.get_element_with_global_id(global_id)
           self.assertEqual(element_one.get_num_nodes(), element_two.get_num_nodes())
           self.assertEqual(network_one.degree(element_one.id_in_frame), network_two.degree(element_two.id_in_frame))
           self.assertAlmostEqual(element_one.calculate_area(), element_two.calculate_area())
           np.testing.assert_almost_equal(element_one.calculate_centroid(), element_two.calculate_centroid())
コード例 #33
0
    def test_track_function_on_second_data(self):
        """Test tracking function on second data pair"""

        mesh_sequence = mesh.read_sequence_from_data(
            path.join(dirname(__file__), 'data', 'first_few_frames'))

        first_mesh = mesh_sequence[1]
        second_mesh = mesh_sequence[2]

        start_time = time.clock()
        tracked_ids = tracking.track(first_mesh, second_mesh)
        end_time = time.clock()

        print 'total time for second data pair is:'
        print end_time - start_time

        first_mesh.plot(
            path.join(dirname(__file__), 'output',
                      'second_mesh_tracked_with_third_total.pdf'),
            color_by_global_id=True,
            total_number_of_global_ids=first_mesh.get_num_elements())

        second_mesh.plot(
            path.join(dirname(__file__), 'output',
                      'third_mesh_tracked_total.pdf'),
            color_by_global_id=True,
            total_number_of_global_ids=first_mesh.get_num_elements())
コード例 #34
0
    def test_track_very_large_random_mesh(self):
        """generate a small random mesh and track it.
        """
        sys.setrecursionlimit(40000)
        mesh_one = mesh.creation.generate_random_tesselation(30,30)
        
        print 'start to copy'
        mesh_two = copy.deepcopy(mesh_one)
        print 'stop to copy'
         
        mesh_one.assign_frame_ids_in_order()
        mesh_two.assign_frame_ids_randomly()
         
        mesh_one.plot(path.join(dirname(__file__),'output','very_large_random_mesh_one.pdf'))
        mesh_two.plot(path.join(dirname(__file__),'output','very_large_random_mesh_two_before_tracking.pdf'))
         
        tracked_ids = tracking.track(mesh_one, mesh_two)
 
        mesh_two.plot(path.join(dirname(__file__),'output','very_large_random_mesh_after_tracking.pdf'), color_by_global_id = True, 
                      total_number_of_global_ids = mesh_one.get_num_elements())
         
        network_one = mesh_one.generate_network()
        network_two = mesh_two.generate_network()
 
        self.assertEqual( len(tracked_ids), mesh_one.get_num_elements())

        for global_id in tracked_ids:
            element_one = mesh_one.get_element_with_frame_id(global_id)
            element_two = mesh_two.get_element_with_global_id(global_id)
            self.assertEqual(element_one.get_num_nodes(), element_two.get_num_nodes())
            self.assertEqual(network_one.degree(element_one.id_in_frame), network_two.degree(element_two.id_in_frame))
            self.assertAlmostEqual(element_one.calculate_area(), element_two.calculate_area())
            np.testing.assert_almost_equal(element_one.calculate_centroid(), element_two.calculate_centroid())       
コード例 #35
0
    def test_track_function_on_first_data(self):
        """See whether we can fully track the mesh using the track function of the tracking module"""

        mesh_sequence = mesh.read_sequence_from_data(
            path.join(dirname(__file__), 'data', 'first_few_frames'))

        first_mesh = mesh_sequence[0]
        second_mesh = mesh_sequence[1]

        start_time = time.clock()
        tracked_ids = tracking.track(first_mesh, second_mesh)
        end_time = time.clock()

        print 'total time for first data pair is:'
        print end_time - start_time

        first_mesh.plot(
            path.join(dirname(__file__), 'output',
                      'first_mesh_tracked_total.pdf'),
            color_by_global_id=True,
            total_number_of_global_ids=first_mesh.get_num_elements())

        second_mesh.plot(
            path.join(dirname(__file__), 'output',
                      'second_mesh_tracked_total.pdf'),
            color_by_global_id=True,
            total_number_of_global_ids=first_mesh.get_num_elements())
コード例 #36
0
    def xest_track_cell_death(self):
        """track a cell death event and identify the cells that are involved in rearrangement"""

        sys.setrecursionlimit(40000)

        mesh_one = mesh.creation.generate_random_tesselation(9, 9)
        mesh_one.save(
            path.join(dirname(__file__), 'output', 'death_mesh_one.mesh'))
        mesh_two = copy.deepcopy(mesh_one)
        #        mesh_one = mesh.load('death_mesh_one.mesh')
        #        mesh_two = mesh.load('death_mesh_two.mesh')

        mesh_one.assign_frame_ids_in_order()
        mesh_two.assign_frame_ids_randomly()

        # build ground truth for testing the mapping
        ground_truth = {}
        for element_index, element in enumerate(mesh_one.elements):
            ground_truth[element.id_in_frame] = mesh_two.elements[
                element_index].id_in_frame

        # pick the element closest to the centre
        most_central_element = mesh_two.find_most_central_element()

        mesh_two.kill_element_with_frame_id(most_central_element.id_in_frame)

        mesh_one.plot(
            path.join(dirname(__file__), 'output',
                      'not_tracked_mesh_before_death.pdf'))
        mesh_two.plot(
            path.join(dirname(__file__), 'output',
                      'not_tracked_mesh_after_death.pdf'))

        tracked_ids = tracking.track(mesh_one, mesh_two)

        mesh_one.plot(path.join(dirname(__file__), 'output',
                                'tracked_mesh_before_death.pdf'),
                      color_by_global_id=True,
                      total_number_of_global_ids=len(tracked_ids))
        mesh_two.plot(path.join(dirname(__file__), 'output',
                                'tracked_mesh_after_death.pdf'),
                      color_by_global_id=True,
                      total_number_of_global_ids=len(tracked_ids))

        # make sure that the entire mesh was tracked (except for the dead cell)
        dangling_elements_one = mesh_one.get_dangling_element_ids(
            ground_truth.keys())
        self.assertGreaterEqual(
            len(tracked_ids),
            max(mesh_one.get_num_elements() - 4,
                mesh_one.get_num_elements() - len(dangling_elements_one) - 1))

        for global_id in tracked_ids:
            # and that the mapping coincides with the ground truth for all tracked ids
            element_one = mesh_one.get_element_with_global_id(global_id)
            element_two = mesh_two.get_element_with_global_id(global_id)
            self.assertEquals(ground_truth[element_one.id_in_frame],
                              element_two.id_in_frame)

        plt.close('all')
コード例 #37
0
def Main():
    Log.Info('============================================')
    Log.Info('Client:')
    Log.Info(' - Product:  {0}'.format(Client.Product))
    Log.Info(' - Platform: {0}'.format(Client.Platform))
    Log.Info('============================================')

    tracking.track('/')

    object_container = ObjectContainer(title2=TITLE)
    object_container.add(DirectoryObject(key=Callback(anime_menu.menu), title='Anime', summary='Browse anime'))
    object_container.add(DirectoryObject(key=Callback(movies_menu.menu), title='Movies', summary='Browse movies'))
    object_container.add(DirectoryObject(key=Callback(tvshows_menu.menu), title='TV Shows', summary="Browse TV shows"))
    object_container.add(PrefsObject(title='Preferences', summary='Preferences for BitTorrent channel'))
    object_container.add(DirectoryObject(key=Callback(about_menu), title='About', summary='About BitTorrent channel', thumb=R('about.png')))
    return object_container
コード例 #38
0
def tvshow_menu(title, tvdb_id):
    tracking.track('/TV Shows/TV Show', { 'Title': title })

    object_container = ObjectContainer(title2=title)
    if 'tvshows_favorites' in Dict and tvdb_id in Dict['tvshows_favorites']:
        object_container.add(DirectoryObject(key=Callback(remove_from_favorites, title='Remove from Favorites', show_title=title, tvdb_id=tvdb_id), title='Remove from Favorites', summary='Remove TV show from Favorites', thumb=R('favorites.png')))
    else:
        object_container.add(DirectoryObject(key=Callback(add_to_favorites, title='Add to Favorites', show_title=title, tvdb_id=tvdb_id), title='Add to Favorites', summary='Add TV show to Favorites', thumb=R('favorites.png')))

    for season_index in SharedCodeService.trakt.tvshows_get_season_index_list(tvdb_id):
        season_object = SeasonObject()
        SharedCodeService.trakt.tvshows_fill_season_object(season_object, tvdb_id, season_index)
        season_object.key = Callback(season_menu, title=season_object.title, show_title=title, tvdb_id=tvdb_id, season_index=season_object.index)
        season_object.rating_key = '{0}-{1}-{2}'.format(title, tvdb_id, season_index)
        object_container.add(season_object)

    return object_container
コード例 #39
0
    def test_translation_special_case(self):
        """load first random mesh, move it, and track it.
        """
        sys.setrecursionlimit(40000)
        large_mesh = mesh.load(path.join(dirname(__file__),'data','special_translation_mesh_one.mesh'))

        large_mesh.assign_frame_ids_in_order()
         
        mesh_one = large_mesh.copy_region_of_interest((3,10),(-1,9))
         
        mesh_two = large_mesh.copy_region_of_interest((5,12),(-1,9))
         
        # Build ground truth
        ground_truth_indices = {}
        for element_index, element in enumerate(mesh_one.elements):
            if element.id_in_frame in mesh_two.frame_id_dictionary:
                ground_truth_indices[element_index] = mesh_two.frame_id_dictionary[element.id_in_frame]
                 
        mesh_one.assign_frame_ids_in_order()
        mesh_two.assign_frame_ids_randomly()
 
        ground_truth = {}
        for element_index, element in enumerate(mesh_one.elements):
            if element_index in ground_truth_indices:
                ground_truth[element.id_in_frame] = mesh_two.elements[ground_truth_indices[element_index]].id_in_frame
         
        print 'call tracker'
        tracked_ids = tracking.track(mesh_one, mesh_two)
#         tracked_ids = tracking.find_maximum_common_subgraph(mesh_one, mesh_two)
        print 'tracker returned'
  
        mesh_one.plot(path.join(dirname(__file__),'output', 'special_translation_mesh_one.pdf'), color_by_global_id = True, 
                      total_number_of_global_ids = len(tracked_ids) )
        mesh_two.plot(path.join(dirname(__file__),'output', 'special_translation_mesh_two.pdf'), color_by_global_id = True, 
                      total_number_of_global_ids = len(tracked_ids) )
          
        network_one = mesh_one.generate_network()
        network_two = mesh_two.generate_network()
  
        self.assertEqual( len(tracked_ids), len(ground_truth) )

#         for frame_id in ground_truth:
#             if mesh_one.get_element_with_frame_id(frame_id).global_id == None:
#                 print 'element with this frame id did not get tracked:'
#                 print frame_id
            
        for global_id in tracked_ids:
            element_one = mesh_one.get_element_with_global_id(global_id)
            element_two = mesh_two.get_element_with_global_id(global_id)
            self.assertEqual(element_one.get_num_nodes(), element_two.get_num_nodes())
            self.assertAlmostEqual(element_one.calculate_area(), element_two.calculate_area())
 
        for global_id in tracked_ids:
            # and that the mapping coincides with the ground truth for all tracked ids
            element_one = mesh_one.get_element_with_global_id(global_id)
            element_two = mesh_two.get_element_with_global_id(global_id)
            self.assertEquals( ground_truth[element_one.id_in_frame], element_two.id_in_frame )
コード例 #40
0
def make_t1_plots(figuresize):

    mesh_one = mesh.creation.generate_random_tesselation(9, 9)
    mesh_two = copy.deepcopy(mesh_one)

    mesh_one.assign_frame_ids_in_order()
    mesh_two.assign_frame_ids_randomly()

    # build ground truth for testing the mapping
    ground_truth = {}
    for element_index, element in enumerate(mesh_one.elements):
        ground_truth[
            element.id_in_frame] = mesh_two.elements[element_index].id_in_frame

    # Perform T1 swap on mesh two
    # First pick a node in the centre
    mesh_centre = mesh_two.calculate_centre()

    # pick the node closest to the centre
    min_distance = 3 * mesh_two.calculate_height()
    for node in mesh_two.nodes:
        distance = np.linalg.norm(node.position - mesh_centre)
        if distance < min_distance:
            min_distance = distance
            most_central_node = node

    # pick a node that shares an edge with this central node
    for local_index, element_node in enumerate(
            most_central_node.adjacent_elements[0].nodes):
        if element_node.id == most_central_node.id:
            num_nodes_this_element = most_central_node.adjacent_elements[
                0].get_num_nodes()
            one_edge_node = most_central_node.adjacent_elements[0].nodes[
                (local_index + 1) % num_nodes_this_element]
            break

    mesh_two.perform_t1_swap(most_central_node.id, one_edge_node.id)

    tracked_ids = tracking.find_maximum_common_subgraph(mesh_one, mesh_two)

    for element in mesh_one.elements:
        element.global_id = None

    for element in mesh_two.elements:
        element.global_id = None

    tracked_ids_all = tracking.track(mesh_one, mesh_two)

    plotname = 't1_swap'

    make_difference_plot(mesh_one, mesh_two, tracked_ids, tracked_ids_all,
                         plotname, figuresize)
コード例 #41
0
def episode_menu(show_title, tvshow_id, season_index, episode_index,
                 first_aired_iso):
    tracking.track('/TV Shows/Episode', {
        'Title': show_title,
        'Season': season_index,
        'Episode': episode_index
    })

    torrent_provider = SharedCodeService.metaprovider.MetaProvider()
    torrent_infos = []
    torrent_provider.tvshows_get_specific_torrents(tvshow_id, season_index,
                                                   episode_index,
                                                   first_aired_iso,
                                                   torrent_infos)

    torrent_infos.sort(key=lambda torrent_info: torrent_info.seeders,
                       reverse=True)

    object_container = ObjectContainer()

    for torrent_info in torrent_infos:
        seeders_leechers_line = '{0}\nSeeders: {1}, Leechers: {2}'.format(
            torrent_info.size, torrent_info.seeders, torrent_info.leechers)

        episode_object = EpisodeObject()

        SharedCodeService.trakt.tvshows_fill_episode_object(
            episode_object, tvshow_id, season_index, episode_index)
        object_container.title2 = episode_object.title

        episode_object.title = torrent_info.release
        episode_object.summary = '{0}\n\n{1}'.format(seeders_leechers_line,
                                                     episode_object.summary)
        episode_object.url = torrent_info.url

        object_container.add(episode_object)

    return object_container
コード例 #42
0
def search_menu(title, query, per_page, movie_count=0):
    tracking.track('/Anime/Search', { 'Query': query })

    torrent_infos = []

    torrent_provider = SharedCodeService.metaprovider.MetaProvider()
    torrent_provider.anime_search(query, torrent_infos)

    torrent_infos.sort(key=lambda torrent_info: torrent_info.seeders, reverse=True)

    object_container = ObjectContainer(title2=title)

    for torrent_info in torrent_infos:
        seeders_leechers_line = '{0}\nSeeders: {1}, Leechers: {2}'.format(torrent_info.size, torrent_info.seeders, torrent_info.leechers)

        videoclip_object         = VideoClipObject()
        videoclip_object.title   = torrent_info.title
        videoclip_object.summary = seeders_leechers_line
        videoclip_object.url     = torrent_info.url

        object_container.add(videoclip_object)

    return object_container
コード例 #43
0
    def test_track_division_standard_case(self):
        """We load a mesh where only one maximum common subgraph should be identified, and track the division event"""

        mesh_one = mesh.load(
            path.join(dirname(__file__), 'data',
                      'standard_simple_division_one.mesh'))
        mesh_two = mesh.load(
            path.join(dirname(__file__), 'data',
                      'standard_simple_division_two.mesh'))

        # First pick a cell in the centre
        mesh_centre = mesh_two.calculate_centre()

        mesh_one.assign_frame_ids_in_order()
        mesh_two.assign_frame_ids_randomly()

        # build ground truth for testing the mapping
        ground_truth = {}
        for element_index, element in enumerate(mesh_one.elements):
            ground_truth[element.id_in_frame] = mesh_two.elements[
                element_index].id_in_frame

        # pick the element closest to the centre
        most_central_element = mesh_two.find_most_central_element()

        mesh_two.divide_element_with_frame_id(most_central_element.id_in_frame)

        tracked_ids = tracking.track(mesh_one, mesh_two)

        mesh_one.plot(path.join(dirname(__file__), 'output',
                                'tracked_standard_mesh_before_division.pdf'),
                      color_by_global_id=True,
                      total_number_of_global_ids=len(tracked_ids))
        mesh_two.plot(path.join(dirname(__file__), 'output',
                                'tracked_standard_mesh_after_division.pdf'),
                      color_by_global_id=True,
                      total_number_of_global_ids=len(tracked_ids))

        # make sure that the entire mesh was tracked (except for the dead cell)
        self.assertEqual(len(tracked_ids), mesh_one.get_num_elements() - 2)

        for global_id in tracked_ids:
            # and that the mapping coincides with the ground truth for all tracked ids
            element_one = mesh_one.get_element_with_global_id(global_id)
            element_two = mesh_two.get_element_with_global_id(global_id)
            self.assertEquals(ground_truth[element_one.id_in_frame],
                              element_two.id_in_frame)

        plt.close('all')
コード例 #44
0
    def test_visualise_search(self):
        """generate a small random mesh and track it.
        """
        sys.setrecursionlimit(40000)
        mesh_one = mesh.creation.generate_random_tesselation(5,5)
        
        mesh_two = copy.deepcopy(mesh_one)
         
        mesh_one.assign_frame_ids_in_order()
        mesh_two.assign_frame_ids_randomly()
         
        tracked_ids = tracking.track(mesh_one, mesh_two)
 
        mesh_two.plot(path.join(dirname(__file__),'output','visualisation_mesh_after_tracking.pdf'), color_by_global_id = True, 
                      total_number_of_global_ids = mesh_one.get_num_elements())
コード例 #45
0
def make_t1_plots(figuresize):

    mesh_one = mesh.creation.generate_random_tesselation(9,9)
    mesh_two = copy.deepcopy(mesh_one)

    mesh_one.assign_frame_ids_in_order()
    mesh_two.assign_frame_ids_randomly()

    # build ground truth for testing the mapping
    ground_truth = {}
    for element_index, element in enumerate(mesh_one.elements):
        ground_truth[element.id_in_frame] = mesh_two.elements[element_index].id_in_frame

    # Perform T1 swap on mesh two 
    # First pick a node in the centre
    mesh_centre = mesh_two.calculate_centre()

    # pick the node closest to the centre
    min_distance = 3*mesh_two.calculate_height()
    for node in mesh_two.nodes:
        distance = np.linalg.norm(node.position - mesh_centre)
        if distance < min_distance:
           min_distance = distance
           most_central_node = node 
               
    # pick a node that shares an edge with this central node
    for local_index, element_node in enumerate(most_central_node.adjacent_elements[0].nodes):
        if element_node.id == most_central_node.id:
            num_nodes_this_element = most_central_node.adjacent_elements[0].get_num_nodes()
            one_edge_node = most_central_node.adjacent_elements[0].nodes[(local_index+1)%num_nodes_this_element]
            break
        
    mesh_two.perform_t1_swap( most_central_node.id, one_edge_node.id )
         
    tracked_ids = tracking.find_maximum_common_subgraph( mesh_one, mesh_two )

    for element in mesh_one.elements:
        element.global_id = None
  
    for element in mesh_two.elements:
        element.global_id = None
  
    tracked_ids_all = tracking.track( mesh_one, mesh_two )
    
    plotname = 't1_swap'
    
    make_difference_plot(mesh_one, mesh_two, tracked_ids, tracked_ids_all, plotname, figuresize)
コード例 #46
0
    def xest_track_cell_death(self):
        """track a cell death event and identify the cells that are involved in rearrangement"""

        sys.setrecursionlimit(40000)

        mesh_one = mesh.creation.generate_random_tesselation(9,9)
        mesh_one.save(path.join(dirname(__file__),'output','death_mesh_one.mesh'))
        mesh_two = copy.deepcopy(mesh_one)
#        mesh_one = mesh.load('death_mesh_one.mesh')
#        mesh_two = mesh.load('death_mesh_two.mesh')

        mesh_one.assign_frame_ids_in_order()
        mesh_two.assign_frame_ids_randomly()

        # build ground truth for testing the mapping
        ground_truth = {}
        for element_index, element in enumerate(mesh_one.elements):
            ground_truth[element.id_in_frame] = mesh_two.elements[element_index].id_in_frame

        # pick the element closest to the centre
        most_central_element = mesh_two.find_most_central_element()
               
        mesh_two.kill_element_with_frame_id(most_central_element.id_in_frame)

        mesh_one.plot(path.join(dirname(__file__),'output','not_tracked_mesh_before_death.pdf' ))
        mesh_two.plot(path.join(dirname(__file__),'output','not_tracked_mesh_after_death.pdf' ))

        tracked_ids = tracking.track( mesh_one, mesh_two )
 
        mesh_one.plot(path.join(dirname(__file__),'output','tracked_mesh_before_death.pdf'), color_by_global_id = True, 
                      total_number_of_global_ids = len( tracked_ids ) )
        mesh_two.plot(path.join(dirname(__file__),'output','tracked_mesh_after_death.pdf'), color_by_global_id = True, 
                      total_number_of_global_ids = len( tracked_ids ) )

        # make sure that the entire mesh was tracked (except for the dead cell)
        dangling_elements_one = mesh_one.get_dangling_element_ids(ground_truth.keys()) 
        self.assertGreaterEqual(len(tracked_ids), 
                         max(mesh_one.get_num_elements() - 4, 
                             mesh_one.get_num_elements() - len(dangling_elements_one) - 1))

        for global_id in tracked_ids:
            # and that the mapping coincides with the ground truth for all tracked ids
            element_one = mesh_one.get_element_with_global_id(global_id)
            element_two = mesh_two.get_element_with_global_id(global_id)
            self.assertEquals( ground_truth[element_one.id_in_frame], element_two.id_in_frame )
            
        plt.close('all')
コード例 #47
0
    def test_visualise_search(self):
        """generate a small random mesh and track it.
        """
        sys.setrecursionlimit(40000)
        mesh_one = mesh.creation.generate_random_tesselation(5, 5)

        mesh_two = copy.deepcopy(mesh_one)

        mesh_one.assign_frame_ids_in_order()
        mesh_two.assign_frame_ids_randomly()

        tracked_ids = tracking.track(mesh_one, mesh_two)

        mesh_two.plot(path.join(dirname(__file__), 'output',
                                'visualisation_mesh_after_tracking.pdf'),
                      color_by_global_id=True,
                      total_number_of_global_ids=mesh_one.get_num_elements())
コード例 #48
0
    def xest_track_9_by_9_random_mesh(self):
        """generate a small random mesh and track it.
        """
        sys.setrecursionlimit(40000)
        mesh_one = mesh.creation.generate_random_tesselation(9,9)
        mesh_one.save(path.join(dirname(__file__),'output','nine_by_nine_permutation_mesh_one.mesh'))
        mesh_two = copy.deepcopy(mesh_one)
         
        mesh_one.assign_frame_ids_in_order()
        mesh_two.assign_frame_ids_randomly()
         
        # build ground truth for testing the mapping
        ground_truth = {}
        for element_index, element in enumerate(mesh_one.elements):
            ground_truth[element.id_in_frame] = mesh_two.elements[element_index].id_in_frame
 
        mesh_one.plot(path.join(dirname(__file__),'output','larger_random_mesh_one.pdf'))
        mesh_two.plot(path.join(dirname(__file__),'output','larger_random_mesh_two_before_tracking.pdf'))
         
        tracked_ids = tracking.track(mesh_one, mesh_two)

        dangling_elements_one = mesh_one.get_dangling_element_ids(ground_truth.keys()) 
        self.assertGreaterEqual(len(tracked_ids), 
                         max(mesh_one.get_num_elements() - 3, 
                             mesh_one.get_num_elements() - len(dangling_elements_one)))
 
        mesh_one.plot(path.join(dirname(__file__),'output','nine_by_nine_permuation_mesh_before.pdf'), color_by_global_id = True, 
                      total_number_of_global_ids = mesh_one.get_num_elements())
        mesh_two.plot(path.join(dirname(__file__),'output','nine_by_nine_permuation_mesh_after.pdf'), color_by_global_id = True, 
                      total_number_of_global_ids = mesh_one.get_num_elements())
         
        network_one = mesh_one.generate_network()
        network_two = mesh_two.generate_network()
 
        for global_id in tracked_ids:
            element_one = mesh_one.get_element_with_global_id(global_id)
            element_two = mesh_two.get_element_with_global_id(global_id)
            self.assertEqual(element_one.get_num_nodes(), element_two.get_num_nodes())
            self.assertEqual(network_one.degree(element_one.id_in_frame), network_two.degree(element_two.id_in_frame))
            self.assertAlmostEqual(element_one.calculate_area(), element_two.calculate_area())
            np.testing.assert_almost_equal(element_one.calculate_centroid(), element_two.calculate_centroid())       

        plt.close('all')
コード例 #49
0
def make_translation_plots(figuresize):
    sys.setrecursionlimit(40000)

    large_mesh = mesh.creation.generate_random_tesselation(15, 8)

    large_mesh.assign_frame_ids_in_order()

    mesh_one = large_mesh.copy_region_of_interest((3, 10), (-1, 9))

    mesh_two = large_mesh.copy_region_of_interest((5, 12), (-1, 9))

    ground_truth_indices = {}
    for element_index, element in enumerate(mesh_one.elements):
        if element.id_in_frame in mesh_two.frame_id_dictionary:
            ground_truth_indices[element_index] = mesh_two.frame_id_dictionary[
                element.id_in_frame]

    mesh_one.assign_frame_ids_in_order()
    mesh_two.assign_frame_ids_randomly()

    ground_truth = {}
    for element_index, element in enumerate(mesh_one.elements):
        if element_index in ground_truth_indices:
            ground_truth[element.id_in_frame] = mesh_two.elements[
                ground_truth_indices[element_index]]

    tracked_ids = tracking.find_maximum_common_subgraph(mesh_one, mesh_two)

    for element in mesh_one.elements:
        element.global_id = None

    for element in mesh_two.elements:
        element.global_id = None

    mesh_one.index_global_ids()
    mesh_two.index_global_ids()

    tracked_ids_all = []
    tracked_ids_all = tracking.track(mesh_one, mesh_two)

    plotname = 'translation'
    make_difference_plot(mesh_one, mesh_two, tracked_ids, tracked_ids_all,
                         plotname, figuresize)
コード例 #50
0
def make_translation_plots(figuresize):
    sys.setrecursionlimit(40000)

    large_mesh = mesh.creation.generate_random_tesselation(15,8)
    
    large_mesh.assign_frame_ids_in_order()

    mesh_one = large_mesh.copy_region_of_interest((3,10),(-1,9))
    
    mesh_two = large_mesh.copy_region_of_interest((5,12),(-1,9))
    
    ground_truth_indices = {}
    for element_index, element in enumerate(mesh_one.elements):
        if element.id_in_frame in mesh_two.frame_id_dictionary:
            ground_truth_indices[element_index] = mesh_two.frame_id_dictionary[element.id_in_frame]
            
    mesh_one.assign_frame_ids_in_order()
    mesh_two.assign_frame_ids_randomly()

    ground_truth = {}
    for element_index, element in enumerate(mesh_one.elements):
        if element_index in ground_truth_indices:
            ground_truth[element.id_in_frame] = mesh_two.elements[ground_truth_indices[element_index]]
    
    tracked_ids = tracking.find_maximum_common_subgraph( mesh_one, mesh_two )
     
    for element in mesh_one.elements:
        element.global_id = None
   
    for element in mesh_two.elements:
        element.global_id = None
   
    mesh_one.index_global_ids()
    mesh_two.index_global_ids()

    tracked_ids_all = []
    tracked_ids_all = tracking.track( mesh_one, mesh_two )
    
    plotname = 'translation'
    make_difference_plot(mesh_one, mesh_two, tracked_ids, tracked_ids_all, plotname, figuresize)
コード例 #51
0
    def test_track_special_case(self):
        """track a cell death event and identify the cells that are involved in rearrangement"""

        sys.setrecursionlimit(40000)

        mesh_one = mesh.load(
            path.join(dirname(__file__), 'data',
                      'special_death_mesh_one.mesh'))
        mesh_two = mesh.load(
            path.join(dirname(__file__), 'data',
                      'special_death_mesh_two.mesh'))

        mesh_one.assign_frame_ids_in_order()
        mesh_two.assign_frame_ids_randomly()

        # build ground truth for testing the mapping
        ground_truth = {}
        for element_index, element in enumerate(mesh_one.elements):
            ground_truth[element.id_in_frame] = mesh_two.elements[
                element_index].id_in_frame

        # pick the element closest to the centre
        most_central_element = mesh_two.find_most_central_element()

        mesh_two.kill_element_with_frame_id(most_central_element.id_in_frame)

        mesh_one.plot(
            path.join(dirname(__file__), 'output',
                      'not_tracked_mesh_before_death.pdf'))
        mesh_two.plot(
            path.join(dirname(__file__), 'output',
                      'not_tracked_mesh_after_death.pdf'))

        tracked_ids = tracking.track(mesh_one, mesh_two)
        #
        #         mesh_one.plot('special_tracked_mesh_before_death.pdf', color_by_global_id = True,
        #                       total_number_of_global_ids = len( tracked_ids ) )
        #         mesh_two.plot('special_tracked_mesh_after_death.pdf', color_by_global_id = True,
        #                       total_number_of_global_ids = len( tracked_ids ) )

        #         tracked_ids = tracking.find_maximum_common_subgraph( mesh_one, mesh_two )
        #         subgraph_finder = tracking.LocalisedSubgraphFinder(mesh_one, mesh_two)
        #         subgraph_finder.find_maximum_common_subgraph()
        #         tracked_ids = tracking.find_maximum_common_subgraph(mesh_one, mesh_two)

        mesh_one.plot(path.join(dirname(__file__), 'output',
                                'special_tracked_mesh_before_death.pdf'),
                      color_by_global_id=True,
                      total_number_of_global_ids=len(tracked_ids))
        mesh_two.plot(path.join(dirname(__file__), 'output',
                                'special_tracked_mesh_after_death.pdf'),
                      color_by_global_id=True,
                      total_number_of_global_ids=len(tracked_ids))

        #         largest_mappings = subgraph_finder.largest_mappings
        #
        #         for mapping_index, large_mapping in enumerate(largest_mappings):
        #
        #             tracked_ids = []
        #
        #             for element_one in mesh_one.elements:
        #                 element_one.global_id = None
        #
        #             for element_two in mesh_two.elements:
        #                 element_two.global_id = None
        #
        #             for global_id, frame_one_id in enumerate(large_mapping):
        #                 mesh_one.get_element_with_frame_id(frame_one_id).global_id = global_id
        #                 mesh_two.get_element_with_frame_id(large_mapping[frame_one_id]).global_id = global_id
        #                 tracked_ids.append(global_id)
        #
        #             mesh_one.index_global_ids()
        #             mesh_two.index_global_ids()
        #
        #             mesh_one.plot('mesh_special_before_death_' + str(mapping_index) + '.pdf', color_by_global_id = True,
        #                           total_number_of_global_ids = len( tracked_ids ) )
        #             mesh_two.plot('mesh_special_after_death_' + str(mapping_index) + '.pdf', color_by_global_id = True,
        #                           total_number_of_global_ids = len( tracked_ids ) )
        #

        # make sure that the entire mesh was tracked (except for the dead cell)
        self.assertEqual(len(tracked_ids), mesh_two.get_num_elements() - 2)

        for global_id in tracked_ids:
            # and that the mapping coincides with the ground truth for all tracked ids
            element_one = mesh_one.get_element_with_global_id(global_id)
            element_two = mesh_two.get_element_with_global_id(global_id)
            self.assertEquals(ground_truth[element_one.id_in_frame],
                              element_two.id_in_frame)

        plt.close('all')
コード例 #52
0
    def test_track_special_case_seven(self):
        """generate a random mesh, copy it, perform a death event, and find maximum common subgraph
           not sure whether this one even works!
        """
        sys.setrecursionlimit(40000)

        mesh_one = mesh.load(
            path.join(dirname(__file__), 'data',
                      'special_death_mesh_seven.mesh'))
        mesh_two = mesh.load(
            path.join(dirname(__file__), 'data',
                      'special_death_mesh_seven.mesh'))

        mesh_one.assign_frame_ids_in_order()
        mesh_two.assign_frame_ids_in_reverse_order()

        # build ground truth for testing the mapping
        ground_truth = {}
        for element_index, element in enumerate(mesh_one.elements):
            ground_truth[element.id_in_frame] = mesh_two.elements[
                element_index].id_in_frame

        # pick the element closest to the centre
        most_central_element = mesh_two.find_most_central_element()

        mesh_two.kill_element_with_frame_id(most_central_element.id_in_frame)

        tracked_ids = tracking.track(mesh_one, mesh_two)
        #         subgraph_finder = tracking.ReducedBacktrackingSubgraphFinder(mesh_one, mesh_two)
        #         subgraph_finder.find_maximum_common_subgraph()
        #
        #         largest_mappings = subgraph_finder.largest_mappings
        #
        #         for mapping_index, large_mapping in enumerate(largest_mappings):
        #
        #             tracked_ids = []
        #
        #             for element_one in mesh_one.elements:
        #                 element_one.global_id = None
        #
        #             for element_two in mesh_two.elements:
        #                 element_two.global_id = None
        #
        #             for global_id, frame_one_id in enumerate(large_mapping):
        #                 mesh_one.get_element_with_frame_id(frame_one_id).global_id = global_id
        #                 mesh_two.get_element_with_frame_id(large_mapping[frame_one_id]).global_id = global_id
        #                 tracked_ids.append(global_id)
        #
        #             mesh_one.index_global_ids()
        #             mesh_two.index_global_ids()
        #
        #             mesh_one.plot('mesh_special_before_death_' + str(mapping_index) + '.pdf', color_by_global_id = True,
        #                         total_number_of_global_ids = len( tracked_ids ) )
        #             mesh_two.plot('mesh_special_after_death_' + str(mapping_index) + '.pdf', color_by_global_id = True,
        #                         total_number_of_global_ids = len( tracked_ids ) )

        mesh_one.plot(path.join(dirname(__file__), 'output',
                                'special_tracked_mesh_7_before_death.pdf'),
                      color_by_global_id=True,
                      total_number_of_global_ids=len(tracked_ids))
        mesh_two.plot(path.join(dirname(__file__), 'output',
                                'special_tracked_mesh_7_after_death.pdf'),
                      color_by_global_id=True,
                      total_number_of_global_ids=len(tracked_ids))

        dangling_elements_one = mesh_one.get_dangling_element_ids(
            ground_truth.keys())
        self.assertGreaterEqual(
            len(tracked_ids),
            max(mesh_one.get_num_elements() - 4,
                mesh_one.get_num_elements() - len(dangling_elements_one) - 1))

        for global_id in tracked_ids:
            # and that the mapping coincides with the ground truth for all tracked ids
            element_one = mesh_one.get_element_with_global_id(global_id)
            element_two = mesh_two.get_element_with_global_id(global_id)
            self.assertEquals(ground_truth[element_one.id_in_frame],
                              element_two.id_in_frame)

        plt.close('all')
コード例 #53
0
def make_double_division_plot():
    """We load a mesh where two maximum common subgraphs will be identified, and track the division event"""

    mesh_one = mesh.creation.generate_random_tesselation(9, 9)
    mesh_two = copy.deepcopy(mesh_one)

    mesh_one.assign_frame_ids_in_order()
    mesh_two.assign_frame_ids_randomly()

    # build ground truth for testing the mapping
    ground_truth = {}
    for element_index, element in enumerate(mesh_one.elements):
        ground_truth[
            element.id_in_frame] = mesh_two.elements[element_index].id_in_frame

    # pick the element closest to the centre
    most_central_element = mesh_two.find_most_central_element()

    # get adjacent element ids
    adjacent_elements = most_central_element.get_ids_of_adjacent_elements()

    # pick one

    second_dividing_cell = adjacent_elements[0]

    mesh_two.divide_element_with_frame_id(most_central_element.id_in_frame)
    mesh_two.divide_element_with_frame_id(second_dividing_cell)

    tracked_ids = tracking.track(mesh_one, mesh_two)

    plotname = 'double_division'

    figuresize = (4, 2.75)

    figure_1 = plt.figure(figsize=figuresize)
    first_polygon_collection = mesh_one.get_polygon_collection(
        color_by_global_id=True, total_number_of_global_ids=len(tracked_ids))
    figure_1.gca().add_collection(first_polygon_collection)
    figure_1.gca().set_aspect('equal')
    figure_1.gca().autoscale_view()
    plt.axis('off')
    this_filename = plotname + '_before_all_colors.pdf'
    figure_1.savefig(this_filename, bbox_inches='tight')
    plt.close(figure_1)

    figure_2 = plt.figure(figsize=figuresize)
    second_polygon_collection = mesh_two.get_polygon_collection(
        color_by_global_id=True, total_number_of_global_ids=len(tracked_ids))
    figure_2.gca().add_collection(second_polygon_collection)
    figure_2.gca().set_aspect('equal')
    figure_2.gca().autoscale_view()
    plt.axis('off')
    this_filename = plotname + '_after_all_colors.pdf'
    figure_2.savefig(this_filename, bbox_inches='tight')
    plt.close(figure_2)

    figure_3 = plt.figure(figsize=figuresize)
    third_polygon_collection = mesh_one.get_polygon_collection(
        color_by_global_id=True, total_number_of_global_ids=len(tracked_ids))
    polygon_list = []
    for element in mesh_one.elements:
        this_polygon = mpl.patches.Polygon(
            [node.position for node in element.nodes], fill=True)
        if element.global_id == None:
            this_polygon.set_facecolor([1.0, 1.0, 1.0])
        else:
            if element.id_in_frame in ground_truth:
                second_element = mesh_two.get_element_with_global_id(
                    element.global_id).id_in_frame
                if ground_truth[element.id_in_frame] == second_element:
                    this_polygon.set_facecolor('#2dec34')
                else:
                    this_polygon.set_facecolor('red')
            else:
                this_polygon.set_facecolor('red')
        polygon_list.append(this_polygon)
    third_polygon_collection = mpl.collections.PatchCollection(
        polygon_list, match_original=True)
    figure_3.gca().add_collection(third_polygon_collection)
    figure_3.gca().set_aspect('equal')
    figure_3.gca().autoscale_view()
    plt.axis('off')
    this_filename = plotname + '_before.pdf'
    figure_3.savefig(this_filename, bbox_inches='tight')
    plt.close(figure_3)

    figure_4 = plt.figure(figsize=figuresize)
    fourth_polygon_collection = mesh_two.get_polygon_collection(
        color_by_global_id=True, total_number_of_global_ids=len(tracked_ids))
    polygon_list = []
    for element in mesh_two.elements:
        this_polygon = mpl.patches.Polygon(
            [node.position for node in element.nodes], fill=True)
        if element.global_id == None:
            this_polygon.set_facecolor([1.0, 1.0, 1.0])
        else:
            if element.id_in_frame in ground_truth.values():
                first_element = mesh_one.get_element_with_global_id(
                    element.global_id).id_in_frame
                if first_element in ground_truth:
                    if ground_truth[first_element] == element.id_in_frame:
                        this_polygon.set_facecolor('#2dec34')
                    else:
                        this_polygon.set_facecolor('red')
                else:
                    this_polygon.set_facecolor('red')
            else:
                this_polygon.set_facecolor('red')
        polygon_list.append(this_polygon)
    fourth_polygon_collection = mpl.collections.PatchCollection(
        polygon_list, match_original=True)
    figure_4.gca().add_collection(fourth_polygon_collection)
    figure_4.gca().set_aspect('equal')
    figure_4.gca().autoscale_view()
    plt.axis('off')
    this_filename = plotname + '_after.pdf'
    figure_4.savefig(this_filename, bbox_inches='tight')
    plt.close(figure_4)
コード例 #54
0
    def test_track_special_t1_swap_4(self):
        """generate a random mesh, copy it, perform a t1 swap on it, and track it.
        """
        sys.setrecursionlimit(40000)

        mesh_one = mesh.load(path.join(dirname(__file__), 'data', 'special_t1_mesh_four.mesh'))
        
        mesh_two = copy.deepcopy(mesh_one)

        mesh_one.assign_frame_ids_in_order()
        mesh_two.assign_frame_ids_randomly()

        # build ground truth for testing the mapping
        ground_truth = {}
        for element_index, element in enumerate(mesh_one.elements):
            ground_truth[element.id_in_frame] = mesh_two.elements[element_index].id_in_frame

        # Perform T1 swap on mesh two 
        # First pick a node in the centre
        mesh_centre = mesh_two.calculate_centre()

        # pick the node closest to the centre
        min_distance = 3*mesh_two.calculate_height()
        for node in mesh_two.nodes:
            distance = np.linalg.norm(node.position - mesh_centre)
            if distance < min_distance:
               min_distance = distance
               most_central_node = node 
               
        # pick a node that shares an edge with this central node
        for local_index, element_node in enumerate(most_central_node.adjacent_elements[0].nodes):
            if element_node.id == most_central_node.id:
                num_nodes_this_element = most_central_node.adjacent_elements[0].get_num_nodes()
                one_edge_node = most_central_node.adjacent_elements[0].nodes[(local_index+1)%num_nodes_this_element]
                break
        
        mesh_two.perform_t1_swap( most_central_node.id, one_edge_node.id )
         
        tracked_ids = tracking.track( mesh_one, mesh_two )
#         subgraph_finder = tracking.LocalisedSubgraphFinder(mesh_one, mesh_two)
#         subgraph_finder.find_maximum_common_subgraph()
#         post_processor = tracking.PostProcessor(mesh_one, mesh_two, subgraph_finder.largest_mappings)
#         post_processor.tidy_current_mapping()
#         post_processor.index_global_ids_from_largest_mappings()
#         network_one = mesh_one.generate_network_of_unidentified_elements()
#         print network_one.nodes()
#         post_processor.altered_fill_in_by_adjacency(network_one)
#         post_processor.index_global_ids()
#         subgraph_finder = tracking.LocalisedSubgraphFinder(mesh_one, mesh_two)
#         subgraph_finder.find_maximum_common_subgraph()
#         largest_mappings = subgraph_finder.largest_mappings
#     
#         for mapping_index, large_mapping in enumerate(largest_mappings):
#     
#             tracked_ids = []
#                 
#             for element_one in mesh_one.elements:
#                 element_one.global_id = None
#     
#             for element_two in mesh_two.elements:
#                 element_two.global_id = None
#     
#             for global_id, frame_one_id in enumerate(large_mapping):
#                 mesh_one.get_element_with_frame_id(frame_one_id).global_id = global_id
#                 mesh_two.get_element_with_frame_id(large_mapping[frame_one_id]).global_id = global_id
#                 tracked_ids.append(global_id)
#     
#             mesh_one.index_global_ids()
#             mesh_two.index_global_ids()
#     
#             mesh_one.plot('mesh_special_before_division_' + str(mapping_index) + '.pdf', color_by_global_id = True, 
#                           total_number_of_global_ids = len( tracked_ids ) )
#             mesh_two.plot('mesh_special_after_division_' + str(mapping_index) + '.pdf', color_by_global_id = True, 
#                           total_number_of_global_ids = len( tracked_ids ) )
#  
        mesh_one.plot(path.join(dirname(__file__),'output','tracked_mesh_before_special_t1_swap_four.pdf'), color_by_global_id = True, 
                      total_number_of_global_ids = mesh_one.get_num_elements() )
        mesh_two.plot(path.join(dirname(__file__),'output','tracked_mesh_after_special_t1_swap_four.pdf'), color_by_global_id = True, 
                      total_number_of_global_ids = mesh_one.get_num_elements() )
           
#         # make sure that the entire mesh was tracked
#         self.assertEqual( len(tracked_ids), mesh_one.get_num_elements() )

#         mesh_one.plot(path.join(dirname(__file__),'output','tracked_mesh_before_special_t1_swap_three.pdf'))
#         mesh_two.plot(path.join(dirname(__file__),'output','tracked_mesh_after_special_t1_swap_three.pdf'))
#         
        for global_id in tracked_ids:
            # and that the mapping coincides with the ground truth for all tracked ids
            element_one = mesh_one.get_element_with_global_id(global_id)
            element_two = mesh_two.get_element_with_global_id(global_id)
            self.assertEquals( ground_truth[element_one.id_in_frame], element_two.id_in_frame )

        plt.close('all')
コード例 #55
0
    def xest_track_t1_swap(self):
        """generate a random mesh, copy it, perform a t1 swap on it, and track it.
        """
        sys.setrecursionlimit(40000)

        mesh_one = mesh.creation.generate_random_tesselation(9,9)
        
        mesh_two = copy.deepcopy(mesh_one)

        mesh_one.assign_frame_ids_in_order()
        mesh_two.assign_frame_ids_randomly()

        mesh_one.save(path.join(dirname(__file__),'output','mesh_t1_one.mesh'))
        mesh_one.save(path.join(dirname(__file__),'output','mesh_t1_two.mesh'))

        # build ground truth for testing the mapping
        ground_truth = {}
        for element_index, element in enumerate(mesh_one.elements):
            ground_truth[element.id_in_frame] = mesh_two.elements[element_index].id_in_frame

        # Perform T1 swap on mesh two 
        # First pick a node in the centre
        mesh_centre = mesh_two.calculate_centre()

        # pick the node closest to the centre
        min_distance = 3*mesh_two.calculate_height()
        for node in mesh_two.nodes:
            distance = np.linalg.norm(node.position - mesh_centre)
            if distance < min_distance:
               min_distance = distance
               most_central_node = node 
               
        # pick a node that shares an edge with this central node
        for local_index, element_node in enumerate(most_central_node.adjacent_elements[0].nodes):
            if element_node.id == most_central_node.id:
                num_nodes_this_element = most_central_node.adjacent_elements[0].get_num_nodes()
                one_edge_node = most_central_node.adjacent_elements[0].nodes[(local_index+1)%num_nodes_this_element]
                break
        
        mesh_two.perform_t1_swap( most_central_node.id, one_edge_node.id )
         
        mesh_one.plot(path.join(dirname(__file__),'output','tracked_mesh_before_t1_swap.pdf'))
        mesh_two.plot(path.join(dirname(__file__),'output','tracked_mesh_after_t1_swap.pdf'))
        
        tracked_ids = tracking.track( mesh_one, mesh_two )

        mesh_one.plot(path.join(dirname(__file__),'output','tracked_mesh_before_t1_swap.pdf'), color_by_global_id = True, 
                      total_number_of_global_ids = len(tracked_ids) )
        mesh_two.plot(path.join(dirname(__file__),'output','tracked_mesh_after_t1_swap.pdf'), color_by_global_id = True, 
                      total_number_of_global_ids = len(tracked_ids) )
         
        # make sure that the entire mesh was tracked
        dangling_elements_one = mesh_one.get_dangling_element_ids(ground_truth.keys()) 
        self.assertGreaterEqual(len(tracked_ids), 
                         max(mesh_one.get_num_elements() - 3, 
                             mesh_one.get_num_elements() - len(dangling_elements_one)))

        for global_id in tracked_ids:
            # and that the mapping coincides with the ground truth for all tracked ids
            element_one = mesh_one.get_element_with_global_id(global_id)
            element_two = mesh_two.get_element_with_global_id(global_id)
            self.assertEquals( ground_truth[element_one.id_in_frame], element_two.id_in_frame )

        plt.close('all')
コード例 #56
0
channel[7].codePhase = 26519
channel[7].status = 'T'
showChannelStatus(channel, settings)

#Track the acquired satellites
trackSamples = getSamples.int8(
    settings.fileName, settings.msToProcess, 11 * samplesPerCode
)  #11*samplesPerCode is number of samples used in acquisition
if settings.skipTracking:
    print "\nLoading old tracking results ... ",
    (trackResults, channel) = pickle.load(open("trackResults.pickle", "rb"))
    print "done"
else:
    startTime = datetime.now()
    print "\nTracking started at", startTime
    (trackResults, channel) = track(trackSamples, channel, settings)
    pickle.dump((trackResults, channel), open("trackResults.pickle", "wb"))
    print "Tracking Done. Elapsed time =", (datetime.now() - startTime)
if settings.plotTrackingLow:
    trackLowFigures = plotTrackingLow(trackResults, settings)
if settings.plotTrackingHigh:
    trackHighFigure = plotTrackingHigh(channel, trackResults, settings)

#Do navigation
if settings.skipNavigation:
    print "\nLoading old navigation results ... ",
    (navSolutions, eph) = pickle.load(open("navResults.pickle", "rb"))
    print "done"
else:
    startTime = datetime.now()
    print "\nNavigation started at", startTime