def init(self):
for x in range(8):
temp = []
for y in range(8):
# print(not blocksState[x][y] & 0x10 == 0)
temp.append(block.Block(self.getPosX(x), self.getPosY(y)))
self.blocks.append(temp)
for x in range(8):
for y in range(8):
# print(not blodcksState[x][y] & 0x10 == 0)
self.groups()[0].add(self.blocks[x][y])
self.redBomb = bomb.Bomb('red', 1200, 200)
self.blackBomb = bomb.Bomb('black', 1200, 200)
self.blackBomb.show()
self.redBomb.setPos(1729, 18)
self.groups()[0].add(self.blackBomb)
self.board = over.Over()
self.groups()[0].add(self.board)
for _ in range(3):
self.blackRadar.append(radar.Radar('black'))
for _ in range(3):
self.redRadar.append(radar.Radar('red'))
for n in range(3):
self.groups()[0].add(self.blackRadar[n])
self.blackRadar[n].setPos(18, n * 106 + 18)
for n in range(3):
self.groups()[0].add(self.redRadar[n])
self.redRadar[n].setPos(1814, n * 106 + 18)
pygame.mouse.set_visible(False)
def __init__(self):
self._running = True
self._display_surf = None
self.active_display = None
self.clock = pygame.time.Clock()
self.now = 0
pygame.init()
pygame.mouse.set_visible(False)
if sys.platform.startswith("win32"):
ctypes.windll.user32.SetProcessDPIAware()
width, height = pygame.display.Info().current_w, pygame.display.Info(
).current_h
self._display_surf = pygame.display.set_mode(
(width, height),
pygame.NOFRAME | pygame.HWSURFACE | pygame.DOUBLEBUF)
self._running = True
self.blip = blip.Blip(width, height)
self.starfield_scanner = starfield_scanner.StarfieldScanner(
width, height, self._display_surf)
self.radar = radar.Radar(width, height, self._display_surf, self.blip)
self.forward_sweep = forward_sweep.ForwardSweep(
width, height, self._display_surf)
self.active_display = self.starfield_scanner
def __init__(self,
name=None,
startPos=(0.0, 0.0),
startHeading=0,
newbrain=None):
Player.__playerNumber += 1
if isinstance(newbrain, brain.Brain):
self.__brain = newbrain
else:
raise BaseException("This is no Brain class")
playerinfo = self.__brain.getPlayerInfo()
if isinstance(playerinfo, dict):
name = playerinfo.get("playername")
self.__teamname = playerinfo.get("teamname")
if (name == None):
name = "Player" + str(Player.__playerNumber)
self.__name = name
screen = tank.Screen()
self.__lifebar = lifebar.LifeBar(name)
self.player_shape = screen.register_shape("./images/body.png",
rotate_angle=-90.0)
self.turret_shape = screen.register_shape("./images/turret.png",
rotate_angle=-90.0)
self.radar_shape = screen.register_shape("./images/radar.png",
rotate_angle=-90.0)
self.player_shape.addChildShape(self.turret_shape, (4, 2))
self.turret_shape.addChildShape(self.radar_shape, (21, 18))
x = startPos[0]
y = startPos[1]
self.__localtank = tank.Turtle(shape=self.player_shape,
startPos=tank.Vec2D(x, y),
undobuffersize=0)
self.__localtank.penup()
self.__localtank.setheading(startHeading)
self.__localtank.extrainfo(gameobjectinfo.Gameobjectinfo(self))
self.__localtank.extrainfo().name(name)
self.__localtank.type("tank")
self.__localtank.pencolor("white")
self.__localtank.setundobuffer(None)
self.__radar = radar.Radar(name=name,
gameobject=self.__localtank,
startPos=tank.Vec2D(x, y))
self.displayLifebar()
self.__status = "playing"
def main():
args = parse_args()
matches = []
try:
with open(args.input_data, 'r') as f:
raw = f.read().split()
except Exception:
print("Error opening file %s" % args.input_data)
return
assert [isinstance(row, str) for row in raw
], ("Input file must contain strings (rows) separated by newlines")
factory = invaders.InvaderFactory(radar.Radar(raw))
cur_invader = factory()
while cur_invader is not None:
x, y = factory.radar.pos_x, factory.radar.pos_y
crab_match = invaders.CRAB.match(cur_invader)
squid_match = invaders.SQUID.match(cur_invader)
if crab_match > squid_match:
candidate = {
'type': 'crab',
'accuracy': crab_match * 100,
'position': (x, y)
}
else:
candidate = {
'type': 'squid',
'accuracy': squid_match * 100,
'position': (x, y)
}
if candidate['accuracy'] >= args.threshold:
matches.append(candidate)
cur_invader = factory()
matches = sorted(matches,
key=lambda x: x[args.sort_by],
reverse=args.sort_by == 'accuracy')
output = "Here's all the possible invaders:\n"
for match in matches:
output += "Possible %s at %s. Accuracy: %.2f%%\n" % (
match['type'], match['position'], match['accuracy'])
print(output)
def main():
# Intervalo de tiempo en el que vamos a medir
tiempo_inicial = datetime.datetime(2016, 3, 5, 1)
tiempo_final = datetime.datetime(2016, 3, 5, 10)
# parametros del generador de senales
amplitud = 0.2
fase = 1
frecuencia = 20*math.pi
# construir un nuevo genrador de senales
generador1 = generador.Generador(amplitud, fase, frecuencia)
# construir un detector
detector1 = detector.Detector()
# establecer un umbral para la detección
threshold = 0.01
# construir un nuevo radar con su propio generador y detector
radar1 = radar.Radar(generador1, detector1)
# parametros para un blanco
amplitud_de_frecuencia_del_blanco = amplitud * 0.06
tiempo_inicial_del_blanco = datetime.datetime(2016, 3, 5, 2)
tiempo_final_del_blanco = datetime.datetime(2016, 3, 5, 4)
# construir un nuevo blanco con sus propios tiempos
blanquito = blanco.Blanco(amplitud_de_frecuencia_del_blanco, tiempo_inicial_del_blanco, tiempo_final_del_blanco)
# construir un medio que contenga el blanco previamente construido
medium = medio.Medio(blanquito)
# Hacer que el radar detecte si existe un blanco en el medio al que apunta.
detected = radar1.detectar(medium, tiempo_inicial, tiempo_final, threshold)
# si el radar detecta un blanco, imprime un mensaje y plotea las dos señales
if detected:
print('Target detected')
radar1.plotear_señal(radar1.signal, radar1.reflected_signal)
# si el radar no detecta un blanco, imprime un mensaje.
else:
print('No target detected')
def main():
# Intervalo de tiempo en el que vamos a medir
tiempo_inicial = datetime.datetime(2016, 3, 5, 1)
tiempo_final = datetime.datetime(2016, 3, 5, 10)
#tiempo_inicial = datetime.datetime(2016, 3, 5, 1)
#tiempo_final = datetime.datetime(2016, 3, 5, 1, 10)
import math
# parametros del generador de senales
amplitud = 0.2
fase = 1
frecuencia = 20 * math.pi
#TODO construir un nuevo genrador de senales
un_generador = generador.Generador(amplitud, fase, frecuencia)
#TODO construir un detector
un_detector = detector.Detector()
#TODO construir un nuevo radar
un_radar = radar.Radar(un_generador, un_detector)
# parametros para un blanco
amplitud_de_frecuencia_del_blanco = amplitud + 100
tiempo_inicial_del_blanco = datetime.datetime(2016, 3, 5, 2)
tiempo_final_del_blanco = datetime.datetime(2016, 3, 5, 4)
#tiempo_inicial_del_blanco = datetime.datetime(2016, 3, 5, 1, 5)
#tiempo_final_del_blanco = datetime.datetime(2016, 3, 5, 1, 7)
#TODO contruir un nuevo blanco
un_blanco = blanco.Blanco(amplitud_de_frecuencia_del_blanco,
tiempo_inicial_del_blanco,
tiempo_final_del_blanco)
#TODO contruir un medio
un_medio = medio.Medio(un_blanco)
#TODO detectar la senial
senial_detectada = un_radar.detectar(un_medio, tiempo_inicial,
tiempo_final)
def main():
# Intervalo de tiempo en el que vamos a medir
tiempo_inicial = datetime.datetime(2016, 3, 5, 1)
tiempo_final = datetime.datetime(2016, 3, 5, 10)
import math
# parametros del generador de senales
amplitud = 0.2
fase = 1
frecuencia = 20 * math.pi
# TODO construir un nuevo genrador de senales
gen = generador.Generador(amplitud, fase, frecuencia)
# TODO construir un detector
detec = detector.Detector(gen)
# parametros para un blanco
amplitud_de_frecuencia_del_blanco = amplitud + 100
tiempo_inicial_del_blanco = datetime.datetime(2016, 3, 5, 2)
tiempo_final_del_blanco = datetime.datetime(2016, 3, 5, 4)
# TODO contruir un nuevo blanco
bln = blanco.Blanco(amplitud_de_frecuencia_del_blanco,
tiempo_inicial_del_blanco, tiempo_final_del_blanco)
# reflejo = bln.reflejar(senal,tiempo_inicial, tiempo_final)
# TODO construir un medio
med = medio.Medio(bln)
# TODO construir un nuevo radar
rad1 = radar.Radar(gen, detec)
fin_senal = rad1.detectar(med, tiempo_inicial, tiempo_final)
rad1.plotear_senal(fin_senal)
def main():
# Intervalo de tiempo en el que vamos a medir
tiempo_inicial = datetime.datetime(2016, 3, 5, 1)
tiempo_final = datetime.datetime(2016, 3, 5, 10)
import math
# parametros del generador de senales
amplitud = 0.2
fase = 1
frecuencia = 20 * math.pi
#TODO construir un nuevo genrador de senales
gen = generador.Generador(amplitud, fase, frecuencia)
#TODO construir un detector
detec = detector.Detector()
#TODO construir un nuevo radar
rad = radar.Radar(gen, detec)
# parametros para un blanco
amplitud_de_frecuencia_del_blanco = amplitud + 0.5
tiempo_inicial_del_blanco = datetime.datetime(2016, 3, 5, 2)
tiempo_final_del_blanco = datetime.datetime(2016, 3, 5, 4)
amplitud_blanco_cluter = amplitud + 100
#TODO contruir un nuevo blanco
mi_blanco = blanco.Blanco(amplitud_de_frecuencia_del_blanco, \
tiempo_inicial_del_blanco, tiempo_final_del_blanco)
mi_blanco_cl = blancoCluter.Blancocluter(amplitud_blanco_cluter, \
tiempo_inicial, tiempo_final)
mis_blancos = [mi_blanco, mi_blanco_cl]
#TODO contruir un medio
mi_medio = medio.Medio(mis_blancos)
#TODO construir un radar
senal_salida = rad.detectar(mi_medio, tiempo_inicial, tiempo_final)
def main():
# Intervalo de tiempo en el que vamos a medir
tiempo_inicial = datetime.datetime(2016, 3, 5, 1)
tiempo_final = datetime.datetime(2016, 3, 5, 10)
import math
# parametros del generador de senales
amplitud = 0.2
fase = 1
frecuencia = 20 * math.pi
#TODO construir un nuevo genrador de senales
oGenerador = generador.Generador(amplitud, fase, frecuencia)
#TODO construir un detector
oDetector = detector.Detector()
#TODO construir un nuevo radar
oRadar = radar.Radar(oGenerador, oDetector)
# parametros para un blanco
amplitud_de_frecuencia_del_blanco = amplitud + 100
tiempo_inicial_del_blanco = datetime.datetime(2016, 3, 5, 2)
tiempo_final_del_blanco = datetime.datetime(2016, 3, 5, 4)
#TODO contruir un nuevo blanco
oBlanco = blanco.Blanco(amplitud_de_frecuencia_del_blanco,
tiempo_inicial_del_blanco, tiempo_final_del_blanco)
oBlancoCluter = blancoCluter.Blancocluter(
amplitud_de_frecuencia_del_blanco, tiempo_inicial_del_blanco,
tiempo_final)
#TODO contruir un medio
oMedio = medio.Medio([oBlanco, oBlancoCluter])
#TODO utilizar un radar
if oRadar.detectar(oMedio, tiempo_inicial, tiempo_final):
print('DETECTO AL MENOS UN BLANCO')
import cv2 as cv
import pySerial
import radar
import schedule
max_sensor_distance_cm = 60
connected = False
serial = None
radar = radar.Radar(max_sensor_distance_cm)
try:
serial = pySerial.PySerial()
connected = True
except:
print("could not connect serial")
def parse_msg(msg):
if len(msg) == 0:
return
degree = int(msg[0])
distance = int(msg[1])
radar.calc_draw_point(degree, distance)
schedule.every(0.01).seconds.do(radar.clean_up_lines)
schedule.every(1).seconds.do(radar.clean_up_dots)
while connected:
schedule.run_pending()
if serial.ser.inWaiting():
line = serial.read_line()
def __init__(self):
self._brc = Broadcaster()
self._radar = radar.Radar()
def _create_factory(self, raw):
r = radar.Radar(raw)
return invaders.InvaderFactory(r)
import radar
r1 = radar.Radar('/dev/tty.usbserial-A90EB0BI', 115200)
r1.show()