Beispiel #1
0
    def get(self):

        mbid=self.request.get('mbid')      
        #data=memcache.get("albumpage %s"%mbid) 
        data=None
        if data is None:
        
        
            album_name,x=album.get_album_mb(mbid)

            artist_name=x[0]
            artist_mbid=x[1]
            bg=image.get_image(artist_mbid,artist_name,'bg')

            tracks=track.get_tracks_mb(mbid)
        

            videos=[]
            for t in tracks:
            
                videos.append([t.video, (t.track_mbid,t.song)])
                taskqueue.add(url='/worker', params={'f':'track.check_hottness("%s","%s")'%(t.track_mbid,t.hottness)})
        
            logo=image.get_image(artist_mbid,artist_name,'artist')

            data={"artist":artist_name,"artist_mbid":artist_mbid,"album":album_name,"tracks":videos,"album_id":mbid,"bg":bg,"logo":logo}
            #memcache.set("albumpage %s"%mbid,data) 
        self.render_album(**data)
Beispiel #2
0
 def mouse_interaction_commands(
         self) -> List[Tuple[pygame.Surface, Callable, Text]]:
     return [
         (img.get_image(self.empire).BARRACK, self.build_barrack,
          'build barrack'),
         (img.get_image(self.empire).WALL, self.build_wall, 'build wall'),
         (img.get_image(self.empire).MINE, self.build_mine, 'build mine')
     ]
Beispiel #3
0
 def no_interaction_commands(
         self) -> List[Tuple[pygame.Surface, Callable, Text]]:
     return [(img.get_image(self.empire).SCOUT, self.create_scout,
              'create scout'),
             (img.get_image(self.empire).BUILDER, self.create_builder,
              'create builder'),
             (img.get_image(self.empire).WARRIOR, self.create_warrior,
              'create warrior'),
             (img.get_image().UPGRADE, self.upgrade, 'Upgrade'),
             (img.get_image().REMOVE, self.delete, 'Remove')]
Beispiel #4
0
def get_artist_albums(artist_mbid):
    logging.error("START OF Artist_ALBUMS")

    url=tools.get_url("musicbrainz","artist_mbid",artist_mbid)
    xml=tools.get_xml(url)

    artist_name= xml.getElementsByTagName("name")[0].childNodes[0].nodeValue
    logo=image.get_image(artist_mbid," ",'artist')     
    background=image.get_image(artist_mbid,"artist_name",'bg')
    
    artist=Artists(artist_name=artist_name, artist_mbid=artist_mbid,disambiguation=" ",letter=artist_name[0], key=ndb.Key('Artists',artist_mbid))
    artist.logo=logo
    artist.background=background
    artist_key=artist.put()  

    logging.error(artist)

    releases=xml.getElementsByTagName("release-group")

    albums=[]
    for rg in releases:
        
        

        try:
            if rg.getElementsByTagName("primary-type")[0].childNodes[0].nodeValue != "Album":
                continue
            error=rg.getElementsByTagName("secondary-type")[0]
            continue
        except:
            try:
                if rg.attributes.get("type").value == "Album":

                    album_mbid=rg.attributes.get("id").value

                    b=Albums(key=ndb.Key(Albums,album_mbid,parent=ndb.Key(Artist,artist_mbid)))

                    b.album_mbid=album_mbid
                    b.album_name=rg.getElementsByTagName("title")[0].childNodes[0].nodeValue
                    b.album_date=rg.getElementsByTagName("first-release-date")[0].childNodes[0].nodeValue
                    b.album_image=image.get_image(album_mbid,b.album_name,key="album")
                    
                    albums.append(b)
                    logging.error(b)
            except:
                continue
    
    albums.sort(key=lambda tup: tup.album_date)

    test=ndb.put_multi(albums)

    logging.error("END OF Artist_ALBUMS")

    return artist,albums
Beispiel #5
0
    def get(self):
        mbid=self.request.get('mbid')
        
        data=memcache.get("bandpage %s"%mbid) 
        if data is None:
            
            artist_mbid=mbid
        
            artist_data,album_data=artist.get_artist_albums(mbid)

            ancestor_key=ndb.Key(Artists,artist_mbid)
            logging.error(ancestor_key)
            
            #qry=Albums.query().ancestor(ancestor_key)

            #logging.error(qry.get())

            for i in Albums.query().iter():
                x=i.key
                logging.error(dir(x))
                logging.error(x.parent())

            similar=artist.get_similar(artist_mbid)
            similar_mbid=[]
            for s in similar:
            
                mbid=s[1]
                s_name=s[0]
                logo=image.get_image(mbid,s[0],'artist')
            
            
                similar_mbid.append((mbid,logo,s_name))
        

            im=image.get_image(artist_data.artist_mbid," ",'artist')
        
            bg=image.get_image(artist_mbid,"artist_name",'bg')

            for a in album_data:
                pass
                #taskqueue.add(url='/worker', params={'f':'track.get_tracks_mb("%s",key="worker")'%a[0]})

            data={"artist":artist_data,"albums":album_data,"similar":similar_mbid, "image":im,"bg":bg}
            logging.error(data)
            """
            data={  artist=Artists
                    albums=[Albums]
                    similar=[Artists]
                    images=[background, logo]

            """
            #memcache.set("bandpage %s"%artist_mbid, data)

        self.render_band(**data)
Beispiel #6
0
    def get(self):
        c=self.request.cookies
        artists=[]
        nologo=[]

        for i in c:
        
            if i[0:11]!='yourlastube':
                pass
            else:
                name,disambiguation=c[i].split(":::")
                name=name.replace("_"," ")
                logging.error(i)
                mbid=i[11:]
                im=image.get_image(mbid,name,key='artist')
                logging.error("DISAMBI")
                logging.error(im)
                if im != []:

                    ar=[mbid,name,disambiguation,im]
                    artists.append(ar)
                    taskqueue.add(url='/worker', params={'f':'artist.get_artist_mb("%s")'%mbid})
                    taskqueue.add(url='/worker', params={'f':'album.get_albums_mb("%s")'%mbid})
                else:
                    ar=[mbid,name,disambiguation,im]
                    nologo.append(ar)


                self.response.headers.add_header("Set-Cookie", "%s=deleted; Expires=Thu, 01-Jan-1970 00:00:00 GMT"%str(i))
        
        if len(artists)==1:
            self.redirect("/artist?mbid=%s"%artists[0][0])
        if len(artists)==0:
            artists=nologo
        self.render_disam(artists)
 def on_btn_Recognize_Clicked(self):
     save_path = "./written_digit.jpg"
     self.__paintBoard.GetContentAsQImage().save(save_path)
     ans, pred = image.predict(model=self.model,
                               image=image.get_image(save_path))
     QMessageBox.question(self, u"识别结果", u"手写数字识别为:" + str(ans),
                          QMessageBox.Yes)
Beispiel #8
0
 def build_mine(self) -> mine.Mine:
     return mine.Mine(health=10,
                      reload=60,
                      cost=configs.MINE_COST,
                      empire=self.empire,
                      image=img.get_image(self.empire).MINE,
                      size=configs.MINE_SIZE)
Beispiel #9
0
async def fact(ctx):
    embed = discord.Embed(title=":thinking: Monkey Fact:",
                          description=random.choice(monkey_facts),
                          colour=discord.Colour.dark_orange())
    embed.set_footer(text='MonkeBot')
    queries = ["thinking monkey", "monkey thinking"]
    embed.set_image(url=get_image(queries, 10))
    await ctx.send(embed=embed)
Beispiel #10
0
    def __init__(self, empire, health: int, speed: int):

        Unit.__init__(self,
                      empire=empire,
                      health=health,
                      speed=speed,
                      size=configs.BUILDER_SIZE,
                      image=img.get_image(empire).BUILDER,
                      cost=configs.BUILDER_COST)
Beispiel #11
0
def img(image_id=None):

    if image_id == None:
        img_response = image.get_latest_image()
        image_id =''
    else:
    	img_response = image.get_image(image_id)

    return flask.render_template('image.html', image_id=image_id, image_name=img_response[1], image_description=img_response[2])
Beispiel #12
0
def image(request, board_id, marked=False, voted=False):
    bingo_board = get_object_or_404(BingoBoard,
                                    board_id=board_id,
                                    game__site=get_current_site(request))
    response = HttpResponse(content_type="image/png")
    filename = _get_image_name(board_id, marked, voted) + ".png"
    response['Content-Disposition'] = 'filename={0}'.format(filename)
    im = image_module.get_image(request.get_host(), bingo_board, marked, voted)
    im.save(response, "png")
    return response
Beispiel #13
0
 def on_open_file(self, event):
     wildcard = "All files(*.*)|*.*"
     dialog = wx.FileDialog(None, "select", os.getcwd(), "", wildcard)
     if dialog.ShowModal() == wx.ID_OK:
         self.file_name.SetValue(dialog.GetPath())
         dialog.Destroy()
     self.image_wx = wx.Image(self.file_name.GetValue(),
                              wx.BITMAP_TYPE_JPEG)
     self.image_pil = image.get_image(self.file_name.GetValue())
     self.show()
Beispiel #14
0
def image(request, board_id, marked=False, voted=False):
    bingo_board = get_object_or_404(
        BingoBoard, board_id=board_id,
        game__site=get_current_site(request))
    response = HttpResponse(content_type="image/png")
    filename = _get_image_name(board_id, marked, voted) + ".png"
    response['Content-Disposition'] = 'filename={0}'.format(filename)
    im = image_module.get_image(request.get_host(), bingo_board, marked, voted)
    im.save(response, "png")
    return response
Beispiel #15
0
    def __init__(self, empire, health: int, speed: int, damage: int):

        AttackUnit.__init__(self,
                            empire=empire,
                            health=health,
                            speed=speed,
                            damage=damage,
                            fight_distance=400,
                            size=configs.SCOUT_SIZE,
                            image=img.get_image(empire).SCOUT,
                            cost=configs.SCOUT_COST)
Beispiel #16
0
def image_raw(image_id=None):
    if image_id == None:
	    img_data = image.get_latest_image()
    else:
        img_data = image.get_image(image_id)

    response = flask.make_response(img_data[0])
    # print img_data[3]
    response.headers['Content-Type'] = img_data[3]

    return response
Beispiel #17
0
 def __init__(self, imageNames, screen):
     self.screen = screen  # screen sur lequelle background est affiché
     self.images = []
     for imageName in imageNames:
         currentImage = pygame.transform.scale(img.get_image(imageName),
                                               (1024, 768))
         self.images.append(currentImage)
     self.lengthX = 0  # X de la largeur cumulé des images de images[]
     for image in self.images:
         self.lengthX += image.get_size()[0]
     self.firstImageX = 0
     self.mooveSpeed = 3
Beispiel #18
0
def image_decode(uid):
    try:
        image = get_image(uid)
        data = Blend(image).decode()
        birr = [int(i) for i in data.split(',')[:-1]]
        str_birr = bytearray_to_str(birr)
        decoded_data = shuffle_text(str_birr, 1)
        if decoded_data.isalnum():
            return decoded_data
        else:
            return None
    except:
        return None
 def __init__(self,
              race,
              name: str = 'DefaultEmpireName',
              start_resources: int = 100):
     self.race = race
     self.name = name
     self.resources = start_resources
     self.icon = img.get_image(self).EMPIRE_ICON
     self.army = army.Army(empire=self)
     self.objects = pygame.sprite.Group()
     self.friends = pygame.sprite.Group()
     self.enemies = pygame.sprite.Group()
     self.cities = pygame.sprite.Group()
 def test_attack(self):
     other_unit = warrior.ElfWarrior(empire=self.empire,
                                     cost=1,
                                     health=1,
                                     speed=1,
                                     damage=2,
                                     fight_distance=300,
                                     size=(100, 100),
                                     image=image.get_image(
                                         self.empire).WARRIOR)
     other_unit.rect.center = (1000, 50)
     self.warrior.attack_target.add(other_unit)
     self.warrior.update()
     self.assertEqual(self.warrior.rect.center, (60, 50))
 def setUp(self) -> None:
     self.empire = empire.Empire(races.DWARFS)
     self.other_empire = empire.Empire(races.ELVES)
     Interface(self.empire, self.other_empire)
     Game(self.empire, self.other_empire)
     self.warrior = warrior.OrcWarrior(empire=self.empire,
                                       cost=10,
                                       health=11,
                                       speed=10,
                                       damage=20,
                                       fight_distance=300,
                                       size=(100, 100),
                                       image=image.get_image(
                                           self.empire).WARRIOR)
 def set_city(self, name: str, cost: int = 50):
     for city_ in self.cities:
         if city_.name == name:
             raise EmpireError(f'City {name} has already exists in {self.name} cities')
     # If city is first (default), it is free.
     if len(self.cities) == 0:
         cost = 0
     city_ = city.City(empire=self,
                       name=name,
                       cost=cost,
                       image=img.get_image(self).CITY,
                       size=(200, 200),
                       health=30)
     self.cities.add(city_)
     return city_
Beispiel #23
0
def bot():
    print("get mention")
    last_id = get_last_id()
    mentions = api.mentions_timeline(last_id['last_seen_id'])
    for mention in reversed(mentions):
        try:
            uname = '@' + str(mention.in_reply_to_screen_name)
            print('=============================================')
            print(mention.in_reply_to_status_id_str + " - " + uname)
        except TypeError as e:
            print("Unknown username", e)
            uname = "@uknown"
        # debug(mention._json)
        if (mention.in_reply_to_status_id):
            mainStatus = get_status(mention.in_reply_to_status_id_str)
            if (check(mention)):
                print(mainStatus.full_text)
                status = remove_mention(
                    remove_media(mainStatus.full_text),
                    len(mention.entities["user_mentions"]) - 2)
                #                status=remove_media(mainStatus.full_text)
                img = json.loads(get_image())
                desc = ' by ' + img['user']['username'] + \
                    ' from unsplash ' + img['links']['html']
                print(desc)
                try:
                    upload(img)
                    generate(status, uname)
                    media_ids = api.media_upload('temp.jpg')
                    api.update_status(status='@' + mention.user.screen_name +
                                      desc,
                                      media_ids=[media_ids.media_id],
                                      in_reply_to_status_id=mention.id)
                except Exception as e:
                    print("------error: " + str(e))
                    store_last_id(mention.id)
            else:
                print("No hashtag")
            store_last_id(mention.id)
    print('=============================================')
Beispiel #24
0
async def player_roll(ctx):
    # determine that the player who !rolled is actually playing
    roller_ID = format(ctx.author.id)
    for player in current_games[ctx.message.guild.id]['player_list']:
        if player.name == roller_ID and player.is_my_turn:
            #set that player as the current player
            print(f"{ctx.author}'s turn.")
            embed_var = discord.Embed(description=f"<@{player.name}>'s turn.")
            roll1 = pig_roll.pig_roll()
            roll2 = pig_roll.pig_roll()

            roll = score.scoring(
                roll1, roll2
            )  # roll two pigs and return a name and a score for the roll
            image.get_image(roll1, roll2)
            file = discord.File('images/rollimage.png',
                                filename='rollimage.png')
            embed_var.set_image(url='attachment://rollimage.png')

            # Player rolls a Pig Out
            if roll['name'] == 'Pig Out':
                player.is_my_turn = False  # end the player's turn
                player.current_score = 0  # reset the player's score for that turn
                embed_var.add_field(
                    name=f"{roll['name']}",
                    value=f"Total score: {player.total_score} points")
                # move to the next player
                if current_games[ctx.message.guild.id]['current_player'] == (
                        len(current_games[ctx.message.guild.id]['player_list'])
                        - 1):
                    current_games[ctx.message.guild.id]['current_player'] = 0
                else:
                    current_games[ctx.message.guild.id]['current_player'] += 1
                current_games[ctx.message.guild.id]['player_list'][
                    current_games[ctx.message.guild.id]
                    ['current_player']].is_my_turn = True  # set the next player's turn
                embed_var.add_field(
                    name='Next player:',
                    value=
                    f"<@{current_games[ctx.message.guild.id]['player_list'][current_games[ctx.message.guild.id]['current_player']].name}>",
                    inline=False)

            # Player rolls an Oinker
            elif roll['name'] == 'Oinker':
                player.is_my_turn = False  # end the player's turn
                player.current_score = 0  # reset the player's score for that turn
                player.total_score = 0  # reset the player's score for the entire game
                embed_var.add_field(
                    name=f"{roll['name']}",
                    value=f"Total score: {player.total_score} points")
                # move to the next player
                if current_games[ctx.message.guild.id]['current_player'] == (
                        len(current_games[ctx.message.guild.id]['player_list'])
                        - 1):
                    current_games[ctx.message.guild.id]['current_player'] = 0
                else:
                    current_games[ctx.message.guild.id]['current_player'] += 1
                current_games[ctx.message.guild.id]['player_list'][
                    current_games[ctx.message.guild.id]
                    ['current_player']].is_my_turn = True  # set the next player's turn
                embed_var.add_field(
                    name='Next player:',
                    value=
                    f"<@{current_games[ctx.message.guild.id]['player_list'][current_games[ctx.message.guild.id]['current_player']].name}>",
                    inline=False)

            # Player rolls anything else
            else:
                player.current_score += roll[
                    'score']  # add the score from the roll
                embed_var.add_field(
                    name=f"{roll['name']} [+ {roll['score']} points]",
                    value=
                    f"Score this turn: {player.current_score} points\nTotal score: {player.total_score + player.current_score} points"
                )
                if player.current_score + player.total_score >= 100:  # check if player has won the game
                    embed_var.add_field(
                        name='You win!',
                        value='Use **!huckthehogs** to play again.',
                        inline=False)
                    # reset game variables
                    current_games[ctx.message.guild.id]['current_player'] = 0
                    current_games[ctx.message.guild.id]['joinable'] = False
                    current_games[ctx.message.guild.id]['game_init'] = False
                    current_games[ctx.message.guild.id]['game_on'] = False
                    current_games[ctx.message.guild.id]['player_list'] = []
                else:
                    embed_var.add_field(
                        name='\u200b',  # prompt the player for their next action
                        value=
                        'Use **!roll** to roll again or **!pass** to move to the next player.',
                        inline=False)

            await ctx.send(file=file, embed=embed_var)
Beispiel #25
0
import cv2
import sys
import datetime
import time
from image import get_image, ImageCaptured
from circular_buffer import Circular

if __name__ == "__main__":
    storage = sys.argv[1]
    port = sys.argv[2]
    ramp_frames = sys.argv[3]
    camera = cv2.VideoCapture(int(port))
    circular = Circular()
    while (cv2.waitKey(1) & 0xFF != ord('q')):
        time.sleep(1)
        image_data = get_image(camera, int(ramp_frames))
        time_now = time.time()
        image = ImageCaptured(image_data, time_now, storage)
        image.filename_from_time()
        image.save_image()
        circular.check_and_clean()
Beispiel #26
0
 def build_wall(self) -> wall.Wall:
     return wall.Wall(health=10,
                      cost=configs.WALL_COST,
                      empire=self.empire,
                      image=img.get_image(self.empire).WALL,
                      size=configs.WALL_SIZE)
Beispiel #27
0
 def build_barrack(self) -> barrack.Barrack:
     return barrack.DwarfsBarrack(health=30,
                                  cost=configs.BARRACK_COST,
                                  empire=self.empire,
                                  image=img.get_image(self.empire).BARRACK,
                                  size=configs.BARRACK_SIZE)
import torch
import image

IMAGE_PATH = "./digit.jpg"
model = torch.load("./model.pkl")
ans, pred = image.predict(model=model,
                          image=image.get_image(image_path=IMAGE_PATH))
print(ans)
Beispiel #29
0
        for obj in Game().objects:
            if obj in Game().objects:
                obj.update()
        # Make place of camera location visible.
        SCREEN.blit(Map().image,
                    (-Interface().camera.x, -Interface().camera.y))

        place_objects_on_display()

        Interface().draw_interface(SCREEN)

        # Show screen.
        pygame.display.update()
        # Cap the framerate.
        CLOCK.tick(50)


if __name__ == '__main__':
    # pygame initialization.
    pygame.init()
    tmp = pygame.display.set_mode(configs.SCR_SIZE)
    pygame.display.set_caption("the Lord of the Strategy")
    pygame.display.set_icon(img.get_image().ICON)
    if not pygame.font.get_init():
        raise SystemExit("Fonts are out-of-service")
    # Global variables initilization.
    SCREEN = tmp
    CLOCK = pygame.time.Clock()

    play_game()
Beispiel #30
0
async def pog(ctx):
    queries = [
        "spider monkey mouth open", "monkey open mouth", "howler monkey mouth"
    ]
    link = get_image(queries, 10)
    await ctx.send(link)
Beispiel #31
0
async def angry(ctx):
    queries = ["angry monkey", "mad monkey"]
    link = get_image(queries, 10)
    await ctx.send(link)
Beispiel #32
0
def convert(dicom_data_sets, dtype):
    """ Convert a list of dicom data sets into Nfiti

        :param dicom_data_sets: list of dicom data sets to convert
        :param dtype: type to use when coverting images
    """

    nifti_data = []

    stacks = get_stacks(dicom_data_sets)
    logger.info(
        "Found {} stack{}".format(len(stacks), "s" if len(stacks) > 1 else ""))

    # Set up progress information
    stacks_count = {}
    stacks_converted = {}
    for key, data_sets_frame_idx in stacks.items():
        series_instance_uid = data_sets_frame_idx[0][0].as_string(
            odil.registry.SeriesInstanceUID)[0]
        stacks_count.setdefault(series_instance_uid, 0)
        stacks_count[series_instance_uid] += 1
        stacks_converted[series_instance_uid] = 0

    def get_element(data_set, tag):
        value = odil_getter._default_getter(data_set, tag)
        return value[0] if value is not None else None

    meta_data_cache = {}
    pixel_data_cache = {}
    # Try to preserve the original stacks order (multi-frame)
    stacks = sorted(
        stacks.items(),
        key=lambda item: numpy.min([x[1] for x in item[1]])
    )
    for stack_index, (keys, data_sets_frame_idx) in enumerate(stacks):
        data_set = data_sets_frame_idx[0][0]

        study = [
            get_element(data_set, odil.registry.StudyID),
            get_element(data_set, odil.registry.StudyDescription)]
        study = [unicode(x) for x in study if x is not None]

        series = [
            get_element(data_set, odil.registry.SeriesNumber),
            get_element(data_set, odil.registry.SeriesDescription)]
        series = [unicode(x) for x in series if x is not None]

        series_instance_uid = data_set.as_string(
            odil.registry.SeriesInstanceUID)[0]

        if stacks_count[series_instance_uid] > 1:
            stack_info = " (stack {}/{})".format(
                1 + stacks_converted[series_instance_uid],
                stacks_count[series_instance_uid])
        else:
            stack_info = ""
        if stack_index == 0:
            logger.info(
                u"Converting {} / {}".format(
                    "-".join(study), "-".join(series)))
        if stack_info:
            logger.debug(
                u"Converting {} / {}{}".format(
                    "-".join(study), "-".join(series), stack_info))
        stacks_converted[series_instance_uid] += 1

        sort(keys, data_sets_frame_idx)
        nifti_img = image.get_image(
            data_sets_frame_idx, dtype, pixel_data_cache)
        nifti_meta_data = meta_data.get_meta_data(
            data_sets_frame_idx, meta_data_cache)
        nifti_data.append((nifti_img, nifti_meta_data))

    # Try to preserve the original stacks order (single-frame)
    nifti_data.sort(
        key=lambda x: numpy.ravel(x[1].get("InstanceNumber", [None])).min())

    for nifti_img, nifti_meta_data in nifti_data:
        meta_data.cleanup(nifti_meta_data)

    series = {}
    for nitfi_img, nifti_meta_data in nifti_data:
        series.setdefault(nifti_meta_data["SeriesInstanceUID"][0], []).append(
            (nitfi_img, nifti_meta_data))

    merged_stacks = []
    for stacks in series.values():
        # Use OrderedDict to keep the relative order
        mergeable = collections.OrderedDict()
        for nifti_img, nifti_meta_data in stacks:
            geometry = nifti_img.shape + \
                tuple(nifti_img.qform.ravel().tolist())
            dt = nifti_img.datatype
            mergeable.setdefault((geometry, dt), []).append(
                (nifti_img, nifti_meta_data))

        for _, stack in mergeable.items():
            if len(stack) > 1:
                logger.info(
                    "Merging {} stack{}".format(
                        len(stack), "s" if len(stack) > 1 else ""))
                merged = merge_images_and_meta_data(stack)
                merged_stacks.append(merged)
            else:
                merged_stacks.append(stack[0])
    return merged_stacks
Beispiel #33
0
	def add_fleet(self, fleet):
		nm = ''
		if 'arrival_turn' in fleet:
			nm = '[%d] '%(fleet['arrival_turn'] - store.max_turn(),)
		nm += fleet['name']
		cp = wx.CollapsiblePane(self, label=nm, style=wx.CP_DEFAULT_STYLE|wx.CP_NO_TLW_RESIZE)
		self.sizer.Add(cp)
		pane = cp.GetPane()
		
		u = store.get_user(fleet['user_id'])
		if u:
			owner_name = u['name']
		else:
			owner_name = '<unknown>'
		sizer = wx.BoxSizer(wx.VERTICAL)
		sizer.Add(wx.StaticText(pane, label='owner: %s'%(owner_name,)), 1, wx.EXPAND)

		speed, rng = store.get_fleet_speed_range(fleet['fleet_id'])
		if speed and rng:
			sizer.Add(wx.StaticText(pane, label='%0.2f / %0.2f'%(speed, rng)), 1, wx.EXPAND)

		#can we contrl the fleet?
		is_controlled = 'login' in u and u['login'] in config.users
		
		if is_controlled and rng >= 1 and (not 'in_transit' in fleet or fleet['in_transit']==0):
			jump_button = wx.ToggleButton(pane, label='jump')
			jump_button.fleet_id = fleet['fleet_id']
			sizer.Add(jump_button, 1, wx.EXPAND)
			
			self.Bind(wx.EVT_TOGGLEBUTTON, self.on_jump, jump_button)
		#else:
		#	print 'user %s not controllable'%(u,)
		
		for unit in store.get_fleet_units(fleet['fleet_id']):
			hbox = wx.BoxSizer(wx.HORIZONTAL)
			sizer.Add(hbox, 1, wx.EXPAND)
			
			proto = store.get_object('proto', {'proto_id':unit['proto_id']})
			if not proto:
				print 'Prototype not found for %s'%(unit,)
				continue
			obj_carp = int(unit['proto_id']), int(proto['carapace']), int(proto['color'])
			
			if is_controlled:
				planet = store.get_object('planet', {'x':self.coord[0], 'y':self.coord[1]})
				inhabited = False
				if planet and planet['user_id'] and int(planet['user_id']) > 0:
					inhabited = True
					
				# get unit actions ( colony, kill-people )
				if not inhabited:
					for action_type in [action.Action.COLONY_COLONISE, action.Action.ARC_COLONISE, action.Action.OUTPOST_COLONISE]:
						action_colonize = store.get_object('proto_action', {'proto_id':proto['proto_id'], 'proto_action_id':action_type})
						if action_colonize:
							c_action = store.get_object('action', {'unit_id':unit['unit_id']})
							if c_action:
								# already colonizing
								cancel_button = wx.Button(pane, label='Cancel colonize %s'%(action.get_colony_population(action_type)))
								cancel_button.cancel_action = u['user_id'], unit['unit_id'], c_action['cancel_id']
								self.Bind(wx.EVT_BUTTON, self.on_cancel_action, cancel_button)
								sizer.Add( cancel_button , 1, wx.EXPAND )
							else:
								colonize_button = wx.Button(pane, label='Colonize %s'%(action.get_colony_population(action_type)))
								colonize_button.action = action_type, unit['unit_id'], fleet['fleet_id'], self.coord, u['user_id']
								self.Bind(wx.EVT_BUTTON, self.on_store_action, colonize_button)
								sizer.Add( colonize_button , 1, wx.EXPAND )

				if inhabited and planet['user_id'] != u['user_id']:
					#TODO: check if our mult, or ally, and notify user about it
					action_kill_people = store.get_object('proto_action', {'proto_id':proto['proto_id'], 'proto_action_id':action.Action.KILL_PEOPLE})
					if action_kill_people:
						c_action = store.get_object('action', {'unit_id':unit['unit_id']})
						if c_action:
							# already colonizing
							cancel_button = wx.Button(pane, label='Cancel kill people')
							cancel_button.cancel_action = u['user_id'], unit['unit_id'], c_action['cancel_id']
							self.Bind(wx.EVT_BUTTON, self.on_cancel_action, cancel_button)
							sizer.Add( cancel_button , 1, wx.EXPAND )
						else:
							colonize_button = wx.Button(pane, label='Kill people')
							colonize_button.action = action.Action.KILL_PEOPLE, unit['unit_id'], fleet['fleet_id'], self.coord, u['user_id']
							self.Bind(wx.EVT_BUTTON, self.on_store_action, colonize_button)
							sizer.Add( colonize_button , 1, wx.EXPAND )

			img = image.get_image( int(unit['proto_id']), int(proto['carapace']), int(proto['color']) )
			
			if img:
				bitmap = wx.StaticBitmap(pane)
				bitmap.SetBitmap(img)
				hbox.Add(bitmap, 1, wx.EXPAND)
			#else:
			#	print 'image not found for unit %s, bc %s, carp %s, color %s'%(unit['unit_id'], int(unit['proto_id']), int(proto['carapace']), int(proto['color']) )

			name = proto['name']
			if not name:
				name = get_unit_name(int(proto['carapace']))
			hbox.Add(wx.StaticText(pane, label=name), 1, wx.EXPAND)

		border = wx.BoxSizer()
		border.Add(sizer, 1, wx.EXPAND|wx.ALL)
		pane.SetSizer(border)
		
		self.sizer.Layout()
		
		self.Bind(wx.EVT_COLLAPSIBLEPANE_CHANGED, self.OnPaneChanged, cp)
		cp.Expand()
		
		cp.Bind(wx.EVT_LEFT_DOWN, self.onFleetSelect)
		self.fleets[cp] = fleet
Beispiel #34
0
from text import reverse_hebrew, annoying_text
from image import get_image, resize_and_caption

import time

if __name__ == '__main__':
    filename = 'output/{}.jpg'.format(int(time.time()))

    get_image(filename)
    resize_and_caption(filename, reverse_hebrew(annoying_text(time.localtime())), filename)

    
Beispiel #35
0
def create_vm_from_image(token, flavor):
    if ide.validate_token(token):
        image = img.get_image(flavor)
        cpt.create_vm(image)
Beispiel #36
0
from image import get_image
from generate import gen
from encrypt import encrypt_blob
from cloud_deploy import dep
import cv2

# get the secret image and save it
images = get_image()
cv2.imwrite("gallery/c_im.jpg", images[0])

# generate the private and public key
gen()

# loading public key
fd = open("public_key.pem", "rb")
public_key = fd.read()
fd.close()

#loading image
fd = open("gallery/c_im.jpg", "rb")
unencrypted_blob = fd.read()
fd.close()

# encryption
encrypted_blob = encrypt_blob(unencrypted_blob, public_key)

#storing encrypted data
fd = open("gallery/encrypted_img.jpg", "wb")
fd.write(encrypted_blob)
fd.close()
Beispiel #37
0
 def default_commands(self) -> List[Tuple[pygame.Surface, Callable, Text]]:
     """ Returns list of default commands.
     Every game object has default commands: `remove` and `upgrade`. """
     return [(img.get_image().UPGRADE, self.upgrade, 'Upgrade'),
             (img.get_image().REMOVE, self.delete, 'Remove')]
Beispiel #38
0
def play_game():
    # pygame initialization start
    pygame.init()
    screen = pygame.display.set_mode(configs.SCR_SIZE)
    pygame.display.set_caption("the Lord of the Strategy")
    icon_surf = img.get_image().ICON
    pygame.display.set_icon(icon_surf)
    clock = pygame.time.Clock()

    if not pygame.font.get_init():
        raise SystemExit("Fonts are out-of-service")
    # pygame initialization finish

    # game objects initialization start
    player_empire = empire.Empire(user_configs.EMPIRE_RACE,
                                  name=user_configs.EMPIRE_NAME,
                                  start_resources=1000)
    enemy_empire = empire.Empire(races.DWARFS,
                                 name='Durden',
                                 start_resources=1000)

    game = Game(player_empire, enemy_empire)
    interface = Interface(player_empire, enemy_empire)

    player_empire.set_city("Nevborn")
    player_default_city = player_empire.get_city("Nevborn")
    player_default_city.rect.x = 500
    player_default_city.rect.centery = world_map.Map().rect.centery

    enemy_empire.set_city("Nuhen")
    enemy_default_city = enemy_empire.get_city("Nuhen")
    enemy_default_city.rect.right = world_map.Map().rect.right - 700
    enemy_default_city.rect.centery = world_map.Map().rect.centery
    StressAI(enemy_empire)
    # game objects initialization start

    rendered = None
    while True:
        mouse_pressed = False

        for event in pygame.event.get():
            if event.type == pygame.QUIT or \
                    event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                pygame.quit()
                quit()
            if event.type == pygame.MOUSEBUTTONDOWN:
                mouse_pressed = True

        key = pygame.key.get_pressed()
        mouse_pos = pygame.mouse.get_pos()

        if mouse_pressed:
            handled = False
            # check if any of interface windows can handle click
            if interface.handle_interface_click(mouse_pos):
                handled = True
            else:
                for obj in game.objects:
                    # check if any of game objects can handle click
                    if obj.handle_click(get_global_mouse_pos(mouse_pos)):
                        handled = True
            if not handled:
                interface.handle_empty_click(mouse_pos)

        # AI is singleton, which has initialized before
        StressAI().play_step()

        # If any of empires is out of cities, finish the game
        if not player_empire.alive() or not enemy_empire.alive():
            return

        interface.move_view(key, mouse_pos)
        # place objects on map
        if rendered is not None:
            game.objects.clear(world_map.Map().image, clear_callback)
        game.objects.update()
        rendered = game.objects.draw(world_map.Map().image)
        interface.draw_interface(screen)
        # show screen
        pygame.display.flip()
        # cap the framerate
        clock.tick(50)