def showIfRightOrFalse(
self, state): # Setting images here for right / false state
activeImage = []
imgLbl = self.ids.right_false_lbl
if state == ("Correct"):
#imgLbl.canvas.clear()
#self.setImgPlaceholder()
del activeImage[0:5]
with imgLbl.canvas.before:
activeImage.append("src/richtigTransparent.png")
Color(.4, .4, .4, 1)
texture = CoreImage(
str(activeImage).strip("[").strip("]").strip("'")).texture
texture.wrap = "repeat"
Rectangle(pos=imgLbl.pos, size=imgLbl.size, texture=texture)
elif state == ("Incorrect"):
#imgLbl.canvas.clear()
#self.setImgPlaceholder()
del activeImage[0:5]
with imgLbl.canvas.before:
activeImage.append("src/falschTransparent.png")
Color(.4, .4, .4, 1)
texture = CoreImage(
str(activeImage).strip("[").strip("]").strip("'")).texture
texture.wrap = "repeat"
Rectangle(pos=imgLbl.pos, size=imgLbl.size, texture=texture)
elif state == ("None"):
#imgLbl.canvas.clear()
#self.setImgPlaceholder()
del activeImage[0:5]
def __init__(self, **kwargs):
Logger.info('ChicagoApp init FIRED')
super(ChicagoApp, self).__init__(**kwargs)
##fix for old file locations
if platform == 'android':
if isfile(App.get_running_app().user_data_dir +
'/game.dat') is False and isfile('./game.dat') is True:
rename('./game.dat',
App.get_running_app().user_data_dir + '/game.dat')
if isfile(App.get_running_app().user_data_dir +
'/shop.dat') is False and isfile('./shop.dat') is True:
rename('./shop.dat',
App.get_running_app().user_data_dir + '/shop.dat')
##Cache all the card images
for path in ('./images/PNG-cards-1.3', './images/back'):
for f in listdir(path):
if isfile(path + '/' + f) and f[-4:] == '.png':
data = io.BytesIO(open(path + '/' + f, "rb").read())
CoreImage(data, ext="png", filename=path + '/' + f)
##and the reset
for f in ('cardborder.png', 'greenTable.jpg', 'simpleTable.jpg'):
data = io.BytesIO(open('./images/' + f, "rb").read())
CoreImage(data, ext=f[-3:], filename='./images/' + f)
if platform == "android":
##set up AdBuddiz
AdBuddiz.setPublisherKey("_ANDROIDADKEY_")
#AdBuddiz.setTestModeActive() # todo - Comment this line before releasing!
AdBuddiz.cacheAds(PythonActivity.mActivity)
elif platform == 'ios' and paidApp is False:
#import <AdBuddiz/AdBuddiz.h>
Ad.setPublisherKey_("_IOSADDKEY_")
Ad.cacheAds()
Ad.setTestModeActive()
pass
def on_update(self):
if not self.value == self.pixel_slider.on_update():
self.value = self.pixel_slider.on_update()
# Scale value based on dominoes produced
width_in_pixels, height_in_pixels = self.calc_width_and_height()
self.imgSmall = self.image.resize(
(width_in_pixels, height_in_pixels), resample=Image.BILINEAR)
# Scale back up using NEAREST to original size
self.pixeate_image = self.imgSmall.resize(
self.image.size, Image.NEAREST).convert("L")
data = BytesIO()
self.pixeate_image.save(data, format='png')
data.seek(0)
# update image
self.pixelate_rect.texture = CoreImage(BytesIO(data.read()),
ext='png').texture
# update label
self.label.text = "This would require " + str(
math.ceil(width_in_pixels * height_in_pixels / 2 /
55)) + " sets of dominoes ( " + str(
width_in_pixels * height_in_pixels //
2) + " dominoes in total )"
# generate domino image on button press
if self.generate_pressed:
# create and update domino image
self.domino_image = calculate.generate_domino_graphics(
(ImageOps.invert(self.imgSmall.convert('RGB'))
if self.color_switch.on else self.imgSmall),
self.imgSmall.size[0], self.imgSmall.size[1], self.filename,
self.color_switch.on)
self.domino_image.show()
print("GENERATION COMPLETE")
data = BytesIO()
# if image will be too large for kivy texture, resize the image so that it can be rendered
if self.domino_image.size[0] * self.domino_image.size[
1] > 256000000:
print("must resize image! original size was:",
self.domino_image.size)
self.domino_image.resize((16000, 16000),
Image.NEAREST).save(data,
format='png')
else:
self.domino_image.save(data, format='png')
data.seek(0)
self.domino_rect.texture = CoreImage(BytesIO(data.read()),
ext='png').texture
# return generate button to former state
self.generate_button.texture = CoreImage(
'./buttons/generate_button.png').texture
self.generate_pressed = False
def build_canvas(self, dt):
# get 3 textures
curdir = dirname(__file__)
arrow_left = CoreImage(join(curdir, 'arrow_left.png')).texture
arrow_middle = CoreImage(join(curdir, 'arrow_middle.png')).texture
arrow_right = CoreImage(join(curdir, 'arrow_right.png')).texture
self.canvas.before.clear()
with self.canvas.before:
cmax = ((self.date_end - self.date_start) / float(self.date_step))
x, y = self.pos
w, h = self.size
fh = 100
bh = 10
cy = y + h / 2
h = fh * 2
r = range(self.date_start, self.date_end, self.date_step)
for index, cx in enumerate(r):
alpha = (cx - self.date_start) / (float(self.date_end) -
float(self.date_start))
# create background of arrow (part of)
c = 0.9 - (0.4 * alpha)
a = 1.0 - 0.4 * alpha
Color(c, c, c, a)
if index == 0:
texture = arrow_left
border = (2, 2, 2, 8)
elif index == len(r) - 1:
texture = arrow_right
border = (2, 126, 2, 2)
else:
texture = arrow_middle
border = (2, 0, 2, 0)
BorderImage(pos=(x, cy - fh), size=(w/cmax, h), texture=texture,
border=border)
# create lines
x = int(x)
if index > 0:
Color(1, 1, 1, .8)
Line(points=[x, cy - fh - bh, x, cy + fh + bh])
# create label (333f43)
label = CoreLabel(text=str(cx),
font_size=14, font_name='fonts/DroidSans.ttf')
label.refresh()
Color(0x33/255., 0x3f/255., 0x43/255.)
# trick to invert the label orientation
tc = label.texture.tex_coords
th, tw = label.texture.size
tc = tc[-2:] + tc[0:-2]
Rectangle(pos=(x + 5, cy - th / 2), size=(tw, th),
texture=label.texture, tex_coords=tc)
x += w / cmax
def slurp_file_to_image(self, filename, container_widget):
# print("slurping {} to {}".format(filename, container_widget))
data = io.BytesIO(open(filename, "rb").read())
self.active_fold_thumbnail = CoreImage(io.BytesIO(
open(filename, "rb").read()),
ext="jpg").texture
container_widget.texture = CoreImage(data, ext="jpg").texture
# container_widget.size = container_widget.texture_size
# print("removing thumb {}".format(filename))
os.remove(filename)
class SpaceShip(Widget):
orientation = NumericProperty(180)
space_game = ObjectProperty(None)
propulsion_texture = ObjectProperty(
CoreImage("atlas://img/space_invader/spaceEffects_005").texture)
REACTOR_SPRITE = [
CoreImage("atlas://img/space_invader/spaceEffects_005").texture,
CoreImage("atlas://img/space_invader/spaceEffects_006").texture,
CoreImage("atlas://img/space_invader/spaceEffects_007").texture,
CoreImage("atlas://img/space_invader/spaceEffects_006").texture,
]
alive = BooleanProperty(True)
gun_cooldown_time = NumericProperty(0.1)
gun_fire_interval = NumericProperty(2.4)
def __init__(self, space_game, **kwargs):
self.space_game = space_game
self.propulsion = cycle(SpaceShip.REACTOR_SPRITE)
self.propulsion_counter = 0
super(SpaceShip, self).__init__(**kwargs)
self.event = Clock.schedule_interval(self.animate_propulsion, FPS)
def on_alive(self, instance, value):
if not self.alive:
if self.event is not None:
self.event.cancel()
if self.parent is not None:
Animation.cancel_all(self)
if self.boom:
self.boom.play()
self.add_debris()
self.parent.remove_widget(self)
def add_debris(self):
dirs = [-2, -1, 0, 1, 2]
for _ in range(10):
tmp_debris = Debris(
velocity_x=choice(dirs) * 60.0,
velocity_y=choice(dirs) * 60.0,
)
self.parent.add_widget(tmp_debris)
tmp_debris.center = self.center
tmp_debris.launch()
def collide_ammo(self, ammo):
raise NotImplementedError()
def animate_propulsion(self, dt):
self.propulsion_counter += 1
if self.propulsion_counter % PROPULSION_FREQUENCY == 0:
self.propulsion_texture = next(self.propulsion)
def load_texture(self, filename):
texture = Cache.get('textures', filename)
if texture is not None:
return texture
if filename == 'lwf_img_replace_character_01.png':
texture = CoreImage(
'../../res/characters/washed_out_cassandra/washed_out_cassandra_bustup.png'
).texture
else:
texture = CoreImage('../../res/lwf/' + filename).texture
Cache.append('textures', filename, texture)
return texture
def iftIter(self,a=0):
if self.iftii >= 2:
self.iftii = 0
print("iftIter", self.iftii)
data = BytesIO(open(self.iftI[self.iftii], "rb").read())
im = CoreImage(data, ext="jpg", filename="image.jpg")
#self.ift.canvas.clear()
self.ift.imgTexture = CoreImage( im, ext='jpg', filename='yy.jpg' )
self.iftii+=1
Clock.schedule_once(self.iftIter, 1.0)
def __init__(self, filepath, **kwargs):
super(Homepage, self).__init__(**kwargs)
self.filepath = filepath
self.filename = filepath.replace('.', '/').split('/')[-2]
Window.clearcolor = (0.2, 0.2, 0.2, 1)
self.color_switch = Switch()
self.canvas.add(self.color_switch)
# LEFT IMAGE #
im = Image.open(filepath).convert("RGBA")
self.image = im.copy()
width, height = self.image.size
self.w_h_ratio = width / height
self.image_rect = Rectangle(texture=CoreImage(self.filepath).texture)
self.canvas.add(self.image_rect)
# CENTER PIXELATED IMAGE & SLIDER #
self.pixeate_image = im.copy()
self.pixelate_rect = Rectangle()
self.canvas.add(self.pixelate_rect)
self.value = None
self.pixel_slider = Slider(
1, ((Window.width - self.image_rect.size[0]) // 2,
(Window.height - self.image_rect.size[1]) // 2),
self.pixelate_rect.size)
self.generate_pressed = False
self.generate_button = Rectangle(
texture=CoreImage('./buttons/generate_button.png').texture)
self.canvas.add(self.generate_button)
# RIGHT DOMINO IMAGE #
self.domino_image = Image.new(mode='RGBA',
size=(width, height),
color=(235, 74, 90, 150))
data = BytesIO()
self.domino_image.save(data, format='png')
data.seek(0)
self.domino_rect = Rectangle(
texture=CoreImage(BytesIO(data.read()), ext='png').texture)
self.canvas.add(self.domino_rect)
self.label = Label()
self.add_widget(self.label)
self.imgSmall = None
self.on_update()
self.on_layout((Window.width, Window.height))
def __init__(self,
level,
goal_music_seq,
duration,
edit_goal_play_status=None):
super(LevelOptions, self).__init__()
self.level = level # level number
self.audio = Audio(2)
self.mixer = Mixer()
self.audio.set_generator(self.mixer)
self.options_bar = Rectangle(pos=(0, 0))
self.home_button = Rectangle(
texture=CoreImage('images/home.png').texture)
self.play_button = Rectangle(
texture=CoreImage('images/play.png').texture)
self.reset_button = Rectangle(
texture=CoreImage('images/reset.png').texture)
self.check_button = Rectangle(
texture=CoreImage('images/check.png').texture)
self.on_layout((Window.width, Window.height))
self.add(colors['grey'])
self.add(self.options_bar)
self.add(colors['green'])
self.add(self.home_button)
self.add(self.play_button)
self.add(self.reset_button)
self.add(self.check_button)
self.is_playing = False
self.start_time = None
self.duration = 0
self.goal_music_seq = None
self.duration_circle = Line()
self.add(self.duration_circle)
# true iff you recently lost or won the game
self.win_or_lose = False
self.win_gen = WaveGenerator(WaveFile("./data/win_sound.wav"))
self.lose_gen = WaveGenerator(WaveFile("./data/lose_sound.wav"))
self.goal_music_seq = goal_music_seq
self.duration = duration
self.button_press_time = None
self.edit_goal_play_status = edit_goal_play_status
def _load(self):
# late import to prevent recursive import.
global CoreImage
if CoreImage is None:
from kivy.core.image import Image as CoreImage
# must be a name finished by .atlas ?
filename = self._filename
assert (filename.endswith('.atlas'))
filename = filename.replace('/', os.sep)
Logger.debug('Atlas: Load <%s>' % filename)
with open(filename, 'r') as fd:
meta = json.load(fd)
Logger.debug('Atlas: Need to load %d images' % len(meta))
d = dirname(filename)
textures = {}
for subfilename, ids in meta.items():
subfilename = join(d, subfilename)
Logger.debug('Atlas: Load <%s>' % subfilename)
# load the image
ci = CoreImage(subfilename)
# for all the uid, load the image, get the region, and put
# it in our dict.
for meta_id, meta_coords in ids.items():
x, y, w, h = meta_coords
textures[meta_id] = ci.texture.get_region(*meta_coords)
self.textures = textures
def clock_thread(self):
while True:
if GLO.stop.is_set(): # stop thread so that the program can quit
return
# get some basic settings
config = ConfigParser.get_configparser('app')
maxw = max(10, int(config.get('settings', 'labw')))
maxh = max(10, int(config.get('settings', 'labh')))
# create blank canvas
canvas_img = pilImage.new('RGB', (maxw, maxh),
color=(255, 255, 255))
# draw text on the canvas
if GLO.font_pool:
self.canvas_drawtext(canvas_img, maxw, maxh, self.textbox.text)
# clean up spaces from text input
#self.textbox.text = re.sub(r'\s\s+', ' ', self.textbox.text.lstrip())
# save png to disk
#canvas_img.save('image_main.png')
# live memory texture
data = BytesIO()
canvas_img.save(data, format='jpeg')
data.seek(0) # yes, this is also important!
self.imbytes = data.read()
im = CoreImage(BytesIO(self.imbytes), ext='jpeg')
self.update_elements(
im
) # instead of self.beeld.texture = im.texture, cannot update root widget from thread
sleep(1)
def openCV_to_kivy(cvImage):
# encode the OpenCV image in PNG format
_, imPNG = cv.imencode(".png", cvImage)
# create a binary data stream for reading that data
data = io.BytesIO(imPNG.tobytes())
# create a Kivy Core Image data structure to hold that data
return CoreImage(data, ext="png")
def texture_update(self, *largs):
if not self.source:
self.texture = None
else:
filename = resource_find(self.source)
self._loops = 0
if filename is None:
return Logger.error(
'Image: Error reading file {filename}'.format(
filename=self.source))
mipmap = self.mipmap
if self._coreimage is not None:
self._coreimage.unbind(on_texture=self._on_tex_change)
try:
if PY2 and isinstance(filename, str):
filename = filename.decode('utf-8')
self._coreimage = ci = CoreImage(filename,
mipmap=mipmap,
anim_delay=self.anim_delay,
keep_data=self.keep_data,
nocache=self.nocache)
except:
Logger.error('Image: Error loading texture {filename}'.format(
filename=self.source))
self._coreimage = ci = None
if ci:
ci.bind(on_texture=self._on_tex_change)
self.texture = ci.texture
def _load_tile(self, tile):
# global db context cannot be shared across threads.
ctx = threading.local()
if not hasattr(ctx, "db"):
ctx.db = sqlite3.connect(self.filename)
# get the right tile
c = ctx.db.cursor()
c.execute(
("SELECT tile_data FROM tiles WHERE "
"zoom_level=? AND tile_column=? AND tile_row=?"),
(tile.zoom, tile.tile_x, tile.tile_y))
# print "fetch", tile.zoom, tile.tile_x, tile.tile_y
row = c.fetchone()
if not row:
tile.state = "done"
return
# no-file loading
try:
data = io.BytesIO(row[0])
except:
# android issue, "buffer" does not have the buffer interface
# ie row[0] buffer is not compatible with BytesIO on Android??
data = io.BytesIO(bytes(row[0]))
im = CoreImage(data, ext='png',
filename="{}.{}.{}.png".format(tile.zoom, tile.tile_x,
tile.tile_y))
if im is None:
tile.state = "done"
return
return self._load_tile_done, (tile, im, )
def get_module_resource_path(file_name, size, resource_package=__name__):
import os
regex = re.compile(
r'^(?:http|ftp)s?://' # http:// or https://
r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' # domain...
r'localhost|' # localhost...
r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})' # ...or ip
r'(?::\d+)?' # optional port
r'(?:/?|[/?]\S+)$',
re.IGNORECASE)
if regex.match(file_name) or os.path.isfile(file_name):
image = Image(source=file_name)
else:
__requires__ = ["CherryPy < 3"
] # Must be set before pkg_resources import
import pkg_resources
resource_path = '/' + file_name
reader = pkg_resources.resource_stream(resource_package, resource_path)
if reader:
stream = io.BytesIO(reader.read())
_, file_extension = os.path.splitext(file_name)
im = CoreImage(stream, ext=file_extension[1:])
image = Image(source="")
image.texture = im.texture
image.reload()
image.size = size
return image
def on_collision_source(self, instance, value):
if value is None:
return
try:
self.__collision_mask = CoreImage(value, keep_data=True)
except:
self.__collision_mask = None
def make_profile_img(self,
width,
do_crop=True,
circ_img=None,
bw=False,
circularize=True):
img_src = os.path.join(PATH_AVATARS, f'{self.app.username}.png')
if not os.path.exists(img_src):
img_src = os.path.join(PATH_GUI_ASSETS, 'avatars',
f'{self.app.username}.png')
if not os.path.exists(img_src):
img_src = PATH_DEFAULT_AVATAR
circ_img = circularize_img(img_src,
width,
do_crop=do_crop,
bw=bw,
circularize=circularize)
avatar_layout = LayoutAvatar()
byte = io.BytesIO(circ_img.read())
img = CoreImage(byte, ext='png')
avatar = ProfileAvatar()
avatar.texture = img.texture
avatar_layout.height = dp(width)
avatar_layout.width = dp(width)
avatar_layout.add_widget(avatar)
return (circ_img, byte, avatar, avatar_layout)
def init(self):
self.step = 1 / 60.
ci = CoreImage("pymunk_logo.png", keep_data=True)
self.logo_lines = self.create_logo_lines(ci)
self.logo_img = ci
self.touches = {}
self.start()
def exibir_imagem(self):
ce = self.ids.conteudo_edicao
ce.clear_widgets()
#############################
# Obtendo Textura da Imagem #
#############################
# Criando Buffer
image_bytes = io.BytesIO()
# Salvando Imagem de PIL no Buffer
ed.img.save(image_bytes, format=ed.img_formato)
# Defininto ponto inicial 0
image_bytes.seek(0)
# Carregando imagem no CoreImage -> Ex: (Buffer, ext='png')
im = CoreImage(image_bytes, ext=ed.img_formato)
# Coletando textura da Imagem de CoreImage
tex = im.texture
# Encerrando Buffer
image_bytes.close()
# ----------------------- #
# Criando Widget de Imagem
img = Image(nocache=True)
# Passando a textura gerada no CoreImage para ele
img.texture = tex
ce.add_widget(img)
def __init__(self, **kwargs):
super(SadpandaRoot, self).__init__(**kwargs)
# list of previous screens
self.screen_list = []
Loader.loading_image = CoreImage("img/loading.gif", size=(16, 16))
Clock.schedule_once(self.start_thread)
def setImage(self, image):
self.source = image
self.texture = CoreImage(self.source).texture
self.rect = Rect(self.rect.x, self.rect.y, self.texture.width,
self.texture.height)
self.width = self.texture.width
self.height = self.texture.height
def build(self):
layout = BoxLayout()
layout01 = BoxLayout(orientation='vertical', size_hint_x=0.3)
layout01.add_widget(start_btn)
layout01.add_widget(pause_btn)
pause_btn.disabled = True
layout01.add_widget(stop_btn)
stop_btn.disabled = True
# layout01.add_widget(self.e1)
# layout01.add_widget(self.l1)
layout01.add_widget(exit_btn)
layout.add_widget(layout01)
layout02 = BoxLayout(orientation='vertical')
img = np.full((1, 1, 3), 0, np.uint8) # placeholder
imgIO = BytesIO()
qr = Image.fromarray(img)
qr.save(imgIO, format='png')
imgIO.seek(0)
imgData = BytesIO(imgIO.read())
with kvbox.canvas:
image = kiImage(source='', pos=kvbox.pos, size=kvbox.size)
image.texture = CoreImage(imgData, ext='png').texture
layout02.add_widget(kvbox)
layout.add_widget(layout02)
return layout
def _read_stream(self):
try:
stream = urllib.request.urlopen(self.url)
except Exception as err:
self.quit = True
Logger.error(
"MjpegViewer: Failed to open url: {} - error: {}".format(
self.url, err))
return None
bytes = b''
while not self.quit:
try:
# read in stream until we get the entire snapshot
bytes += stream.read(1024)
a = bytes.find(b'\xff\xd8')
b = bytes.find(b'\xff\xd9')
if a != -1 and b != -1:
jpg = bytes[a:b + 2]
bytes = bytes[b + 2:]
data = io.BytesIO(jpg)
im = CoreImage(data, ext="jpeg", nocache=True)
return im
except Exception as err:
Logger.error(
"MjpegViewer: Failed to read_queue url: {} - error: {}".
format(self.url, err))
return None
def itemProfile(self):
"""
:return: Get all information of the item
"""
# return image, title, priceType, saleStatus, postTime
# need for view item action
qry = "SELECT image, title, description, priceType,likeness,dislike,saleStatus, approvalStatus FROM ItemInfo WHERE itemID = %s;" % self.itemID
self.cursor.execute(qry)
profile = self.cursor.fetchone()
self.title, self.descrpition, self.priceType = profile[1], profile[
2], profile[3]
self.likeness, self.dislike = profile[4], profile[5]
self.saleStatus, self.approvalStatus = profile[6], profile[7]
self.image = CoreImage(BytesIO(profile[0]), ext="png").texture
qry = "SELECT ownerID from ItemOwner WHERE itemID = %s;" % self.itemID
self.cursor.execute(qry)
self.owner = self.cursor.fetchone()[0]
qry = "SELECT frequency from ItemView WHERE itemID = %s;" % self.itemID
self.cursor.execute(qry)
self.views = self.cursor.fetchone()[0]
self.rating = 0
if self.priceType: # for bidding
self.getBiddingInfo()
self.getBiddings()
else: # for fixed
self.getFixedinfo()
self.getRating()
def show_note(self, item_id):
self.note_content = self.get_note_data(item_id)
self.main.actionbar_widget_controller.set_title(self.note_content[3])
texts = self.note_content[7:12]
images = self.note_content[12:17]
results = self.note_content[17:22]
for i in range(5):
if texts[i]:
label = NoteLabel(text=texts[i])
self.note_layout_widgets.append(label)
self.note_layout.add_widget(label)
if images[i]:
pic = io.BytesIO(images[i])
im = CoreImage(pic, ext="jpeg")
image = NoteImage()
image.texture = im.texture
self.note_layout_widgets.append(image)
self.note_layout.add_widget(image)
if results[i]:
label = NoteResult(text=results[i])
self.note_layout_widgets.append(label)
self.note_layout.add_widget(label)
def texture_update(self, *largs):
if not self.source:
self._clear_core_image()
return
source = resource_find(self.source)
if not source:
Logger.error('Image: Not found <%s>' % self.source)
self._clear_core_image()
return
if self._coreimage:
self._coreimage.unbind(on_texture=self._on_tex_change)
try:
self._coreimage = image = CoreImage(
source,
mipmap=self.mipmap,
anim_delay=self.anim_delay,
keep_data=self.keep_data,
nocache=self.nocache
)
except Exception:
Logger.error('Image: Error loading <%s>' % self.source)
self._clear_core_image()
image = self._coreimage
if image:
image.bind(on_texture=self._on_tex_change)
self.texture = image.texture
def edit_screen(self, title, texts, images, results):
self.reset_counters()
self.main.container.ids.add_note_screen.ids.submit_button.text = Text.data[
'update']
for i in range(5):
if texts[i]:
widget = TextInput(text=f'{texts[i]}',
size_hint=(0.95, None),
height=200)
self.text_inputs.append(widget)
self.note_body_layout.add_widget(widget)
self.common(Const.TEXT, widget, 0)
self.text_counter += 1
if images[i]:
data = io.BytesIO(images[i])
data.seek(0)
im = CoreImage(io.BytesIO(data.read()), ext="jpeg")
image = NoteImage(im=data.getvalue())
image.texture = im.texture
self.images.append(image)
self.note_body_layout.add_widget(image)
self.common(Const.IMAGE, image, 1)
self.image_counter += 1
if results[i]:
widget = TextInput(text=f'{results[i]}',
size_hint=(0.95, None),
height=200)
self.results.append(widget)
self.note_body_layout.add_widget(widget)
self.common(Const.RESULT, widget, 0)
self.result_counter += 1
def _load(self):
# must be a name finished by .atlas ?
filename = self._filename
assert(filename.endswith('.atlas'))
filename = filename.replace('/', os.sep)
Logger.debug('Atlas: Load <%s>' % filename)
with open(filename, 'r') as fd:
meta = json.load(fd)
Logger.debug('Atlas: Need to load %d images' % len(meta))
d = dirname(filename)
textures = {}
for subfilename, ids in meta.items():
subfilename = join(d, subfilename)
Logger.debug('Atlas: Load <%s>' % subfilename)
# load the image
ci = CoreImage(subfilename)
# <RJ> this is the fix for pixel art
ci.texture.mag_filter = 'nearest'
# for all the uid, load the image, get the region, and put
# it in our dict.
for meta_id, meta_coords in ids.items():
x, y, w, h = meta_coords
textures[meta_id] = ci.texture.get_region(*meta_coords)
self.textures = textures
def _update_frame(self, _):
"""
Update the image to the new frame
"""
try:
# Try to receive a frame
frame_message = self.connection.socket.recv(block=False)
# If you did not receive a frame do not update the screen
if frame_message is None:
return
logging.debug(f"FRAME:Received frame with "
f"length: {len(frame_message.content)}")
self.connection.socket.send(
Message(MESSAGE_TYPES["controller"], "Message received"))
frame_data = io.BytesIO(frame_message.content)
frame_data.seek(0)
logging.debug("FRAME:Creating core image")
self.texture = CoreImage(frame_data, ext=self.image_format).texture
logging.debug("FRAME:Reloading screen")
self.reload()
logging.debug("FRAME:SCREEN UPDATED")
except Exception as e: # TODO: dont be broad
print(e)
self.stop()
logging.error("FRAME:An error occurred", exc_info=True)
return
