def draw(self):
self.bg = DISPLAY.subsurface(self).copy()
clipxy = DISPLAY.get_clip()
DISPLAY.set_clip(self)
gfxdraw.box(DISPLAY,self,BGCOLOR)
x,y = self.itemsrect.topleft
if self.index != None and not (1 << self.index)&self._exc:
gfxdraw.box(DISPLAY,self.hlRect,BGHIGHTLIGHT)
gfxdraw.rectangle(DISPLAY,self.hlRect,BORDER_HL)
x += self.lineheight/3
for idx,item in enumerate(self.itemslist):
isExc = (1 << idx)&self._exc
isStr = isinstance(item,str)
text = FONT.render(item if isStr else item.label,1,FGLOWLIGHT if isExc else FGCOLOR)
if not isStr:
self.arrowRect.topright = self.itemsrect.right-self.lineheight/3,y
DISPLAY.blit(FONT.render(Arrow,1,FGLOWLIGHT if isExc else FGCOLOR),self.arrowRect)
r = DISPLAY.blit(text,(x,y))
y += self.lineheight
gfxdraw.vline(DISPLAY,self.left,self.top,self.bottom-1,BORDER_LEFT)
gfxdraw.hline(DISPLAY,self.left,self.right-1,self.top,BORDER_LEFT)
gfxdraw.vline(DISPLAY,self.right-1,self.top+1,self.bottom-1,BORDER_RIGHT)
gfxdraw.hline(DISPLAY,self.left+1,self.right-1,self.bottom-1,BORDER_RIGHT)
DISPLAY.set_clip(clipxy)
return self
def draw_surface_rewards(self, rewards):
last_rewards_surface_shape = (self.left_menu_shape[0], 180)
last_rewards_surface = pygame.Surface(last_rewards_surface_shape, pygame.SRCALPHA, 32).convert_alpha()
last_rewards_surface.fill(self.left_menu_tile_color)
last_rewards_surface.blit(self.bold_white_render('Last timestep reward'), (30, 20))
reward_offset = (50, 40)
x_offset = 180
line_spacing = 20
rewards_labels = ['Loads cut', 'Productions cut', 'Last action cost', 'Distance to initial grid',
'Line capacity usage']
for i, (reward, label) in enumerate(zip(rewards, rewards_labels)):
last_rewards_surface.blit(self.text_render(label), (reward_offset[0], reward_offset[1] + i * line_spacing))
last_rewards_surface.blit(self.value_render('%.1f' % reward if reward else '0'),
(reward_offset[0] + x_offset if reward >= 0 else reward_offset[0] + x_offset - 7
, reward_offset[1] + i * line_spacing))
last_rewards_surface.blit(self.text_render('Total'),
(reward_offset[0], reward_offset[1] + (i + 1) * line_spacing))
last_rewards_surface.blit(self.value_render('%.1f' % np.sum(rewards)),
(reward_offset[0] + x_offset - 7, reward_offset[1] + (i + 1) * line_spacing))
gfxdraw.hline(last_rewards_surface, 0, last_rewards_surface_shape[0], 0, (64, 64, 64))
gfxdraw.hline(last_rewards_surface, 0, last_rewards_surface_shape[0], last_rewards_surface_shape[1] - 1,
(64, 64, 64))
return last_rewards_surface
def draw_world_borders():
top = int((c.world.top_left[0] - c.player.center[1])*zoom + screensize[1]/2)
left = int((c.world.top_left[1] - c.player.center[0])*zoom + screensize[0]/2)
bottom = int((c.world.bottom_right[0] - c.player.center[1])*zoom + screensize[1]/2)
right = int((c.world.bottom_right[1] - c.player.center[0])*zoom + screensize[0]/2)
if (top >= 0): gfxdraw.hline(screen, 0, screensize[0], top, (0,0,0))
if (bottom <= screensize[1]): gfxdraw.hline(screen, 0, screensize[0], bottom, (0,0,0))
if (left >= 0): gfxdraw.vline(screen, left, 0, screensize[1], (0,0,0))
if (right <= screensize[0]): gfxdraw.vline(screen, right, 0, screensize[1], (0,0,0))
def pinta(s,sel): # Sel: seleccionado o no # NOS PASAMOS A MATERIAL DESIGN if sel: col = (255,255,255) else: col = s.BTNFONDO s.sf.fill(col,(s.posx,s.posy,s.width,s.btnheight),0) # Pinta caja pgd.hline(s.sf,s.posx,s.posx+s.width,math.trunc(s.posy+s.btnheight)-1,s.BTNSEP) # Pinta separador # Pinta icono s.sft = s.sff.render(s.texto, 1, (0,0,0), col) # Pinta texto s.sf.blit(s.sft,(s.posx+s.btnheight,s.posy+s.btnheight/2-s.sft.get_size()[1]/2)) # Render texto
def draw_surface_n_overflows(self):
img_rtl = self.create_plot_number_overflows(n_hours=7 * 24, left_xlabel=' 7 days ago ')
n_overflows_surface = pygame.Surface((img_rtl.get_width(), 2 * img_rtl.get_height() + 30),
pygame.SRCALPHA, 32).convert_alpha()
n_overflows_surface.fill(self.left_menu_tile_color)
n_overflows_surface.blit(self.bold_white_render('Number of overflows'), (30, 10))
n_overflows_surface.blit(img_rtl, (0, 30))
gfxdraw.hline(n_overflows_surface, 0, n_overflows_surface.get_width(), 0, (64, 64, 64))
gfxdraw.hline(n_overflows_surface, 0, n_overflows_surface.get_width(), n_overflows_surface.get_height() - 1,
(64, 64, 64))
return n_overflows_surface
def draw_surface_relative_thermal_limits(self):
img_rtl = self.create_plot_relative_thermal_limits(n_hours=24, left_xlabel='24 hours ago')
rtl_curves_surface = pygame.Surface((img_rtl.get_width(), 2 * img_rtl.get_height() + 30),
pygame.SRCALPHA, 32).convert_alpha()
rtl_curves_surface.fill(self.left_menu_tile_color)
rtl_curves_surface.blit(self.bold_white_render('Lines capacity usage'), (30, 10))
rtl_curves_surface.blit(img_rtl, (0, 30))
gfxdraw.hline(rtl_curves_surface, 0, rtl_curves_surface.get_width(), 0, (64, 64, 64))
gfxdraw.hline(rtl_curves_surface, 0, rtl_curves_surface.get_width(), rtl_curves_surface.get_height() - 1,
(64, 64, 64))
return rtl_curves_surface
def draw(self):
DISPLAY.blit(self.bg,self.rect)
gfxdraw.box(DISPLAY,self.rect,BGCOLOR)
gfxdraw.vline(DISPLAY,self.rect.left,self.rect.top,self.rect.bottom-1,BORDER_LEFT)
gfxdraw.hline(DISPLAY,self.rect.left,self.rect.right-1,self.rect.top,BORDER_LEFT)
gfxdraw.vline(DISPLAY,self.rect.right-1,self.rect.top+1,self.rect.bottom-1,BORDER_RIGHT)
gfxdraw.hline(DISPLAY,self.rect.left+1,self.rect.right-1,self.rect.bottom-1,BORDER_RIGHT)
x = self.rect.x + self.lineheigth/3
if self.index > -1:
gfxdraw.box(DISPLAY,self.rects[self.index].inflate(-2,-2),BGHIGHTLIGHT)
for item in self.menuboxlist:
x = DISPLAY.blit(FONT.render(item.label,1,FGCOLOR),(x,self.rect.y)).right+self.lineheigth
return self.rect
def draw(bgcolor,fgcolor,topleftcolor,bottomrightcolor):
gfxdraw.box(DISPLAY,self,bgcolor)
gfxdraw.vline(DISPLAY,self.left,self.top,self.bottom-1,topleftcolor)
gfxdraw.hline(DISPLAY,self.left,self.right-1,self.top,topleftcolor)
gfxdraw.vline(DISPLAY,self.right-1,self.top+1,self.bottom-1,bottomrightcolor)
gfxdraw.hline(DISPLAY,self.left+1,self.right-1,self.bottom-1,bottomrightcolor)
clipxy = DISPLAY.get_clip()
DISPLAY.set_clip(self.inflate(-2,-2))
if self.type == SWITCH:
label = FONT.render(self.label if not self.switch else self.switchlabel,1,fgcolor)
else:
label = FONT.render(self.label,1,fgcolor)
DISPLAY.blit(label,label.get_rect(center=self.center))
DISPLAY.set_clip(clipxy)
def __init__(self):
self.patternOverlay = Surface((960,540))
for i in range(1,541,4):
gfxdraw.hline(self.patternOverlay,
0,960,i,
(255,255,255))
gfxdraw.hline(self.patternOverlay, ## draws to hlines of white
0,960,i+1,
(255,255,255))
gfxdraw.hline(self.patternOverlay, ## and two hlines of black
0,960,i+2,
(0,0,0))
gfxdraw.hline(self.patternOverlay, ## throughout the whole screen
0,960,i+3,
(0,0,0))
self.patternOverlay.set_alpha(5)
## ^^ All pertains to the pattern overlayed on the whole game
## Stars
self.stars = [] # holds all the star positions on the screen
self.starFrame = 0 #starFrame for use with blinking or w/e
self.starExt = 0 # the extension on the star (blinking)
for i in range(10):
self.makeStar() #generates 10 stars
self.staticSurf = Surface((960,540)) ## Static Overlay Surface
self.staticLayers = []
self.staticFrame = 0
self.explosionSurface = Surface((960,540),SRCALPHA)
self.explosionList = []
def draw(self):
DISPLAY.blit(self.bg,self.rect)
gfxdraw.box(DISPLAY,self.rect,BGCOLOR)
gfxdraw.vline(DISPLAY,self.rect.left,self.rect.top,self.rect.bottom-1,BORDER_LEFT)
gfxdraw.hline(DISPLAY,self.rect.left,self.rect.right-1,self.rect.top,BORDER_LEFT)
gfxdraw.vline(DISPLAY,self.rect.right-1,self.rect.top+1,self.rect.bottom-1,BORDER_RIGHT)
gfxdraw.hline(DISPLAY,self.rect.left+1,self.rect.right-1,self.rect.bottom-1,BORDER_RIGHT)
x = self.rect.x + self.lineheigth/3
if self.mouse_in or self: gfxdraw.box(DISPLAY,self.rect.inflate(-2,-2),BGHIGHTLIGHT)
clipxy = DISPLAY.get_clip()
DISPLAY.set_clip(self.rect.inflate(-self.lineheigth/3*2,-2))
DISPLAY.blit(FONT.render(self.menu.label,1,FGCOLOR),(x,self.rect.y))
DISPLAY.set_clip(clipxy)
return self.rect
def drawScoreboard(self):
# Frame
gfxdraw.vline(self.renderSurface, viewConst.GameSize[0], 0,
viewConst.GameSize[1], viewConst.sbColor)
for i in range(1, modelConst.PlayerNum):
gfxdraw.hline(self.renderSurface, viewConst.GameSize[0],
viewConst.ScreenSize[0],
viewConst.GameSize[1] // modelConst.PlayerNum * i,
viewConst.sbColor)
# Team Names
pos = [(viewConst.GameSize[0] +
viewConst.GameSize[1] // modelConst.PlayerNum,
viewConst.GameSize[1] // modelConst.PlayerNum * i +
viewConst.GameSize[1] // (modelConst.PlayerNum * 8))
for i in range(modelConst.PlayerNum)]
for i, player in enumerate(self.model.player_list):
color = viewConst.aliveTeamColor if player.is_alive else viewConst.deadTeamColor
teamName = self.teamNameFont.render(player.name, True, color)
self.renderSurface.blit(teamName, pos[i])
# Team Scores
pos = [(x, y + viewConst.GameSize[1] // 32) for x, y in pos]
for i, player in enumerate(self.model.player_list):
color = viewConst.Color_Black
teamScore = self.teamScoreFont.render(
str(self.model.score_list[player.index]), True, color)
self.renderSurface.blit(teamScore, pos[i])
# Team Balls
pos = [(viewConst.GameSize[0] + viewConst.GameSize[1] //
(modelConst.PlayerNum * 2),
viewConst.GameSize[1] // (modelConst.PlayerNum * 2) * i)
for i in range(1, modelConst.PlayerNum * 2, 2)]
radius = int(viewConst.GameSize[1] // (modelConst.PlayerNum * 2) * 0.7)
for i, player in enumerate(self.model.player_list):
if self.model.have_scoreboard[i]:
ballPos = tuple([
x + random.randint(-5, 5) for x in pos[i]
]) if self.model.bombtimer[i] != -1 else pos[i]
if self.model.bombtimer[i] == modelConst.bombtime - 1:
self.vibrationSound.play()
gfxdraw.filled_circle(self.renderSurface, *ballPos, radius,
player.color)
# Team Player Lengths
for i, player in enumerate(self.model.player_list):
length = str(len(player.body_list)) if player.is_alive else '0'
color = viewConst.teamLengthColor if self.model.have_scoreboard[
i] else viewConst.Color_Black
teamLength = self.teamLengthFont.render(length, True, color)
self.blit_at_center(self.renderSurface, teamLength, pos[i])
def draw_man(i):
if i == 1:
draw.vline(scr, 500, 350, 450, (255, 255, 255))
elif i == 2:
draw.aacircle(scr, 500, 320, 20, (255, 255, 255))
elif i == 3:
draw.hline(scr, 490, 450, 380, (255, 255, 255))
elif i == 4:
draw.hline(scr, 510, 550, 380, (255, 255, 255))
elif i == 5:
draw.line(scr, 490, 450, 460, 500, (255, 255, 255))
elif i == 6:
draw.line(scr, 510, 450, 540, 500, (255, 255, 255))
py.display.update()
return
def drawRoundRect(surface, x, y, width, height, bevelsize, color):
gfxdraw.hline(surface, x + bevelsize, (x + width) - bevelsize, y, color)
gfxdraw.hline(surface, x + bevelsize, (x + width) - bevelsize, y + height,
color)
gfxdraw.vline(surface, x, y + bevelsize, (y + height) - bevelsize, color)
gfxdraw.vline(surface, x + width, y + bevelsize, (y + height) - bevelsize,
color)
gfxdraw.arc(surface, x + bevelsize, y + bevelsize, bevelsize, 180, 270,
color)
gfxdraw.arc(surface, x + width - bevelsize, y + bevelsize, bevelsize, 270,
360, color)
gfxdraw.arc(surface, x + bevelsize, y + height - bevelsize, bevelsize, 90,
180, color)
gfxdraw.arc(surface, x + width - bevelsize, y + height - bevelsize,
bevelsize, 0, 90, color)
def render(self):
scr = pygame.display.get_surface()
res = self.app.config['screen']
if self.bg:
gfxdraw.box(scr, ((0, 0), res), self.bg)
x = (self.x + self.app.context.offset_x) % self.size
y = (self.y + self.app.context.offset_y) % self.size
while x < res[0]:
gfxdraw.vline(scr, x, 0, res[1], self.fg)
x += self.size
while y < res[1]:
gfxdraw.hline(scr, 0, res[0], y, self.fg)
y += self.size
def draw_surface_loads_curves(self):
# Loads curve surface: retrieve images surfaces, stack them into a common surface, plot horizontal lines
# at top and bottom of latter surface
img_loads_curve_week = self.create_plot_loads_curve(n_hours=7 * 24, left_xlabel=' 7 days ago ')
img_loads_curve_day = self.create_plot_loads_curve(n_hours=24, left_xlabel='24 hours ago')
loads_curve_surface = pygame.Surface(
(img_loads_curve_week.get_width(), 2 * img_loads_curve_week.get_height() + 30),
pygame.SRCALPHA, 32).convert_alpha()
loads_curve_surface.fill(self.left_menu_tile_color)
loads_curve_surface.blit(self.bold_white_render('Total demand'), (30, 10))
loads_curve_surface.blit(img_loads_curve_week, (0, 30))
loads_curve_surface.blit(img_loads_curve_day, (0, 30 + img_loads_curve_week.get_height()))
gfxdraw.hline(loads_curve_surface, 0, loads_curve_surface.get_width(), 0, (64, 64, 64))
gfxdraw.hline(loads_curve_surface, 0, loads_curve_surface.get_width(), loads_curve_surface.get_height() - 1,
(64, 64, 64))
return loads_curve_surface
def drawStars(self):
for s in self.stars:
gfxdraw.vline(screen,s[0],
s[1] - 2 - self.starExt,
s[1] + 2 + self.starExt,
(220,220,220))
gfxdraw.hline(screen,
s[0] - 2 - self.starExt,
s[0] + 2 + self.starExt,
s[1], (220,220,220))
gfxdraw.filled_circle(screen,s[0],s[1],1+self.starExt,(255,255,255))
self.starFrame += 1
if self.starFrame > 10:
self.starFrame = 0
if self.starFrame > 5:
self.starExt = 1
else: self.starExt = 0
def pinta(s,sel): # Sel: seleccionado o no # NOS PASAMOS A MATERIAL DESIGN if not MATERIAL: if sel: col = (255,255,255) else: col = s.color s.sf.fill((s.color[0]/2,s.color[1]/2,s.color[2]/2),(s.posx,s.posy,s.width,s.height),0) # Pinta borde s.sf.fill(col,(s.posx+s.border/2,s.posy+s.border/2,s.width-s.border,s.height-s.border),0) # Pinta centro s.sft = s.sff.render(s.texto, 0, (0,0,0), col) # Pinta texto s.sf.blit(s.sft,(s.posx+s.width/2-s.sft.get_size()[0]/2,s.posy+s.height/2-s.sft.get_size()[1]/2)) # Render texto else: if sel: col = (255,255,255) else: col = s.BTNFONDO s.height = 72 s.sf.fill(col,(s.posx,s.posy,s.width,s.height),0) # Pinta caja pgd.hline(s.sf,s.posx,s.posx+s.width,math.trunc(s.posy+s.height)-1,s.BTNSEP) # Pinta separador # Pinta icono s.sft = s.sff.render(s.texto, 0, (0,0,0), col) # Pinta texto s.sf.blit(s.sft,(s.posx+72,s.posy+s.height/2-s.sft.get_size()[1]/2)) # Render texto
def hline(self, x1, x2, y, color):
"""x軸に平行な直線を描画します.
Parameters
----------
x1 : int
直線の始点のx座標.
x2 : int
直線の終点のx座標.
y : int
直線のy座標.
color : tuple of int
描画に使用される色を指定します.
"""
return gfx.hline(self.pg.screen, x1, x2, y, color)
def render(self, mode="human"):
screen_width = 600
screen_height = 400
if self.screen is None:
pygame.init()
pygame.display.init()
self.screen = pygame.display.set_mode(
(screen_width, screen_height))
if self.clock is None:
self.clock = pygame.time.Clock()
self.surf = pygame.Surface((screen_width, screen_height))
self.surf.fill((255, 255, 255))
self.track = gfxdraw.hline(self.surf, 0, screen_width,
int(screen_height / 2), (0, 0, 255))
if len(self._path) > 1:
for p in range(len(self._path) - 1):
gfxdraw.line(
self.surf, int(self._path[p][0] * 100),
int(screen_height / 2 + self._path[p][1] * 100),
int(self._path[p + 1][0] * 100),
int(screen_height / 2 + self._path[p + 1][1] * 100),
(255, 0, 0))
self.surf = pygame.transform.flip(self.surf, False, True)
self.screen.blit(self.surf, (0, 0))
if mode == "human":
pygame.event.pump()
self.clock.tick(self.metadata["render_fps"])
pygame.display.flip()
if mode == "rgb_array":
return np.transpose(np.array(pygame.surfarray.pixels3d(
self.screen)),
axes=(1, 0, 2))
else:
return self.isopen
def pantalla_refresh(sf):
global pts,mpts
global xbw,xdev
global fq,fqc,bw
global modelabel,bwlabel,fqlabel1,fqlabel2
global ftqc, numx
global maxfill_enable, maxpts_enable, refreshfq
global azoom, base
global fft_sf,top_sf
global sq,xsq,asq,smval,smvaladj,possq,sqstate
global frame, count
global menusf, stereosf
a = FFTANCHO/2 # media pantalla
pleft = fqlabel1.get_size()[0]/2 + fqlabel2.get_size()[0]/2
fft_sf.fill(BGCOLOR) # Borra BW Más rapido que reescribir.
# PINTA ESCALA
for x in range(12): # Escala FFT
y = int(FFTALTO - (x*(FFTALTO/12))*azoom) + base
if y > 0 :
pgd.hline(fft_sf,0,FFTANCHO,y,ESCCOLOR)
lb = ftdev1.render(str((12-x)*-10), 0, ESCCOLOR,BGCOLOR) # pinta db text
fft_sf.blit(lb, (0,y-10)) # Pinta db label
# Pinta BW
if nobaile: txdev = FFTANCHO/2;
else: txdev = xdev
txbw = 2*xbw
tcodo = txdev - txbw/2
if not nobaile or (nobaile and (frame % 10) > 4 ): # parapedea dev si introscan
if tmode != "FM W" and tmode != "FM ST": # WFM no tiene ancho de banda
if tmode == "USB":
txbw /= 2
tcodo = txdev
elif tmode == "LSB":
txbw /= 2
tcodo = txdev - txbw
fft_sf.fill(BWCOLOR2,(tcodo,BWY,txbw,FFTALTO-BWY),0) # Pinta BW
pgd.rectangle(fft_sf,(tcodo,BWY,txbw,FFTALTO-BWY),BWCOLOR)
pgd.vline(fft_sf,int(txdev),0,FFTALTO,DEVCOLOR) # Pinta linea dev
# PINTA MAX
if maxpts_enable: # Pintta puntos de max
mpts += [(FFTANCHO,FFTALTO),(0,FFTALTO)]
pgd.polygon(fft_sf,mpts,MAXCOLOR)
# PINTA FILL
if fftfill_enable: # Pintta FFT relleno (Más rápido que el fill)
for x in pts: pgd.vline(fft_sf,x[0],x[1],FFTALTO,FILLCOLOR)
# PINTA FFT
pgd.polygon(fft_sf,pts,FGCOLOR) # pinta FFT
# PINTA DETECT
if detect_enable : # Pinta detector picos
for x in dtc : pgd.circle(fft_sf,x[0],x[1],10,DETECTCOLOR)
# PINTA DEV text
if not nobaile or (nobaile and (frame % 10) > 4):
if tmode != "FM W" and tmode != "FM ST":
fft_sf.blit(bwlabel, (txdev-bwlabel.get_size()[0]/2,BWY+2)) # Pinta bw label
fft_sf.blit(fqlabel1, (txdev-pleft,BWY-22)) # Pinta dev label
fft_sf.blit(fqlabel2, (txdev-pleft+fqlabel1.get_size()[0]+4,BWY-20))
fft_sf.blit(modelabel,(txdev-modelabel.get_size()[0]/2,BWY-40)) # Pinta mode label
# pinta Sqelch
tc = SQCOLOR
if not sqstate: tc = (0,200,0) # Si está levantado pinta verde
pgd.hline(fft_sf,0,FFTANCHO,xsq+base, tc)
fsq = ftdev2.render(' SQ '+str(sq)+ ' ', 0, DEVCOLORHZ,(100,25,25))
fft_sf.blit(fsq, (FFTANCHO-fsq.get_size()[0],xsq-10+base)) # Pinta bw label
possq = (FFTANCHO-fsq.get_size()[0]+25,xsq-12+base+12) # Guardo posicion para el botón
#pgd.circle(fft_sf,possq[0],possq[1],50,(200,200,200))
#asq = tsq
# pinta smeter
pgd.box(top_sf,(smx+13,25,sml-28,9),(0,0,0))
pgd.box(top_sf,(smx+13,27,smval*smvaladj,6),(255,50,50))
# PINTA CIFRAS DE FREQ SI HAN CAMBIADO
if refreshfq:
sp = 4
size = 24
numx = [] # Repinta el indicador de frecuencia
txt = format(fqc,'010d')
txt = txt[:-9]+'.'+txt[-9:-6]+'.'+txt[-6:-3]+','+txt[-3:]
lon = len(txt)
anc = 0
for x in range(lon):
if txt[x] in ['.',','] :
col = BGCOLOR
anc = size / 2
else :
col = BGFQCCOLOR
anc = size
px = (TOPANCHO/2) - (lon+sp)*size/2 + (x*(size+sp)) # Calcula posición
fqclabel = ftqc.render(txt[x], 1, FQCCOLOR, col) # pinta fqc text
top_sf.blit(fqclabel,(px,0)) # blit
if txt[x] not in ['.',','] : numx += [px] # Almacena la coordenada del numero
# PARPADEA BOTON ROJO IF REC
if rec:
if frame == FPS/2:
pgd.filled_circle(top_sf, smx+sml+TOPALTO/2, TOPALTO/2, TOPALTO/4, BGCOLOR) #Borra botón rojo izquierda smeter
if frame == 1:
pgd.filled_circle(top_sf, smx+sml+TOPALTO/2, TOPALTO/2, TOPALTO/4, tc) #Pinta botón del color del smeter
# Pinta STEREO si STEREO
if REAL and tmode == "FM ST":
if (sdr.probe_st.level() > 0.5 ):
top_sf.blit(stereosf,(250,8))
else:
pgd.box(top_sf,(250,0,40,TOPALTO),BGCOLOR)
# Pinta BIRDIES
for i in birds:
fft_sf.blit(fbd, (i+((birdsize-16)/2),FFTALTO-16))
# PINTA MENU IF ANY
if mn : mn.refresca()
# Flipea/Vuelca la pantalla
pg.display.flip()
refreshfq = False
frame = (frame % FPS) +1
count += 1
def render(self, mode="human"):
import pygame
from pygame import gfxdraw
screen_width = 600
screen_height = 400
world_width = self.x_threshold * 2
scale = screen_width / world_width
polewidth = 10.0
polelen = scale * (2 * self.length)
cartwidth = 50.0
cartheight = 30.0
if self.state is None:
return None
x = self.state
if self.screen is None:
pygame.init()
pygame.display.init()
self.screen = pygame.display.set_mode(
(screen_width, screen_height))
if self.clock is None:
self.clock = pygame.time.Clock()
self.surf = pygame.Surface((screen_width, screen_height))
self.surf.fill((255, 255, 255))
l, r, t, b = -cartwidth / 2, cartwidth / 2, cartheight / 2, -cartheight / 2
axleoffset = cartheight / 4.0
cartx = x[0] * scale + screen_width / 2.0 # MIDDLE OF CART
carty = 100 # TOP OF CART
cart_coords = [(l, b), (l, t), (r, t), (r, b)]
cart_coords = [(c[0] + cartx, c[1] + carty) for c in cart_coords]
gfxdraw.aapolygon(self.surf, cart_coords, (0, 0, 0))
gfxdraw.filled_polygon(self.surf, cart_coords, (0, 0, 0))
l, r, t, b = (
-polewidth / 2,
polewidth / 2,
polelen - polewidth / 2,
-polewidth / 2,
)
pole_coords = []
for coord in [(l, b), (l, t), (r, t), (r, b)]:
coord = pygame.math.Vector2(coord).rotate_rad(-x[2])
coord = (coord[0] + cartx, coord[1] + carty + axleoffset)
pole_coords.append(coord)
gfxdraw.aapolygon(self.surf, pole_coords, (202, 152, 101))
gfxdraw.filled_polygon(self.surf, pole_coords, (202, 152, 101))
gfxdraw.aacircle(
self.surf,
int(cartx),
int(carty + axleoffset),
int(polewidth / 2),
(129, 132, 203),
)
gfxdraw.filled_circle(
self.surf,
int(cartx),
int(carty + axleoffset),
int(polewidth / 2),
(129, 132, 203),
)
gfxdraw.hline(self.surf, 0, screen_width, carty, (0, 0, 0))
self.surf = pygame.transform.flip(self.surf, False, True)
self.screen.blit(self.surf, (0, 0))
if mode == "human":
pygame.event.pump()
self.clock.tick(self.metadata["render_fps"])
pygame.display.flip()
if mode == "rgb_array":
return np.transpose(np.array(pygame.surfarray.pixels3d(
self.screen)),
axes=(1, 0, 2))
else:
return self.isopen
def doit(calibrar):
global SALIDA
global cal,elmax
# CLS
#sf.fill(BGCOLOR)
# Pinta grafica
for i in range(10):
pgd.hline(sf,0,VEC_SZ,i*50,FONDO)
elpaso = (FMAX-FMIN)/(int(VEC_SZ)/50)
for i in range(int(VEC_SZ/50)+1):
pgd.vline(sf,i*50,0,500,FONDO)
#if (i % 3 ) == 0:
fs = ft.render(str((FMIN+(elpaso*i))/1e6), 1,FGCOLOR, BGCOLOR)
sf.blit(fs, (i*50,505))
#print(str((FMIN+(elpaso*i))/1e6))
for i in np.arange(0,VEC_SZ,RES):
# SINTONIZA
fq = FMIN+(STEP*i)
sdr.set_freq(fq)
f2 = int(fq)
if fq>50e6: f2 = 125e6-int(fq)
if fq>125e6: f2 = int(fq)-125e6
f.write("F"+str(int(f2))+"\n")
# ESPERA
time.sleep(0.04)
~clk.tick(30)
#BORRA EL DATO ANTERIOR
#pg.gfxdraw.pixel(sf,i,FFTALTO-int(py[i]),BGCOLOR);
pg.draw.rect(sf,BGCOLOR,(i-RES,0,RES,10));
pg.draw.line(sf,BGCOLOR,(i,FFTALTO-int(py[i])),(i+RES,FFTALTO-int(py[i])));
# COJE DATO. EL MAYOR DEL FFT
ma = -10000000;
for x in sdr.fft_probe.level():
if x > ma: ma = x;
#print(ma)
t = 5+m.log10(ma)
# Usa calibración
if cal[i] != 0.0: t = t+ (elmax-cal[i])
if calibrar:
cal[i] = t
if t > elmax: elmax=t
# GUARDA PA LUEGO
py[i] = t*FFTK;
# PINTA
#pg.gfxdraw.pixel(sf,i,FFTALTO-int(py[i]),FGCOLOR);
pg.draw.rect(sf,FGCOLOR,(i,0,RES,10));
pg.draw.line(sf,FGCOLOR,(i,FFTALTO-int(py[i])),(i+RES,FFTALTO-int(py[i])));
# Muestra
pg.display.flip()
for evt in pg.event.get():
if (evt.type == pg.QUIT):
SALIDA = True
if SALIDA: quit()
