def chess(screen, cola, colb): for i in xrange(WIDTH): for j in xrange(HEIGHT): if (i + j) % 2: c = cola else: c = colb RSDL_helper.set_pixel(screen, i, j, c)
def stripes_m(screen, cola, colb): for j in xrange(WIDTH): for i in xrange(HEIGHT): k = j * WIDTH + i if k % 2: c = cola else: c = colb RSDL_helper.set_pixel(screen, i, j, c)
def draw_pixels(self): #pass str = "" for y in range(self.height): # str += "\n" for x in range(self.width): #if y%2 == 0 or True: # px = self.get_pixel_color(x, y) # str += ["#", "%", "+", " ", " "][px] RSDL_helper.set_pixel(self.screen, x, y, self.get_pixel_color(x, y))
def draw_pixel(self, x, y, color): color = self.COLOR_MAP[color] start_x = x * self.scale start_y = y * self.scale if self.scale > 1: for x in range(self.scale): for y in range(self.scale): RSDL_helper.set_pixel(self.screen, start_x + x, start_y + y, color) else: RSDL_helper.set_pixel(self.screen, start_x, start_y, color)
def test_image_pixels(): for filename in ["demo.jpg", "demo.png"]: image = RIMG.Load(os.path.join(autopath.this_dir, filename)) assert image assert rffi.getintfield(image.c_format, 'c_BytesPerPixel') in (3, 4) RSDL.LockSurface(image) result = {} try: rgb = lltype.malloc(rffi.CArray(RSDL.Uint8), 3, flavor='raw') try: for y in range(23): for x in range(y % 13, 17, 13): color = RSDL_helper.get_pixel(image, x, y) RSDL.GetRGB(color, image.c_format, rffi.ptradd(rgb, 0), rffi.ptradd(rgb, 1), rffi.ptradd(rgb, 2)) r = rffi.cast(lltype.Signed, rgb[0]) g = rffi.cast(lltype.Signed, rgb[1]) b = rffi.cast(lltype.Signed, rgb[2]) result[x, y] = r, g, b finally: lltype.free(rgb, flavor='raw') finally: RSDL.UnlockSurface(image) RSDL.FreeSurface(image) for x, y in result: f = (x * 17 + y * 23) / float(17 * 17 + 23 * 23) expected_r = int(255.0 * (1.0 - f)) expected_g = 0 expected_b = int(255.0 * f) r, g, b = result[x, y] assert abs(r - expected_r) < 10 assert abs(g - expected_g) < 10 assert abs(b - expected_b) < 10
def test_blit_rect(self): surface = RSDL.CreateRGBSurface(0, 150, 50, 32, r_uint(0x000000FF), r_uint(0x0000FF00), r_uint(0x00FF0000), r_uint(0xFF000000)) fmt = surface.c_format color = RSDL.MapRGB(fmt, 255, 0, 0) RSDL.FillRect(surface, lltype.nullptr(RSDL.Rect), color) paintrect = RSDL_helper.mallocrect(75, 0, 150, 50) dstrect = lltype.malloc(RSDL.Rect, flavor='raw') try: color = RSDL.MapRGB(fmt, 255, 128, 0) RSDL.FillRect(surface, paintrect, color) rffi.setintfield(dstrect, 'c_x', 10) rffi.setintfield(dstrect, 'c_y', 10) rffi.setintfield(dstrect, 'c_w', 150) rffi.setintfield(dstrect, 'c_h', 50) RSDL.BlitSurface(surface, lltype.nullptr(RSDL.Rect), self.screen, dstrect) RSDL.Flip(self.screen) finally: lltype.free(dstrect, flavor='raw') lltype.free(paintrect, flavor='raw') RSDL.FreeSurface(surface) self.check("Half Red/Orange rectangle(150px * 50px) at the top left, 10 pixels from the border")
def test_set_color_key(self): # prepare fillrect = RSDL_helper.mallocrect(10, 10, 30, 30) RSDL.FillRect(self.src_surf, fillrect, self.blue) lltype.free(fillrect, flavor='raw') assert RSDL.SetColorKey(self.src_surf, RSDL.SRCCOLORKEY, self.blue) == 0 # draw RSDL_helper.blit_complete_surface(self.src_surf, self.dst_surf, 0, 0) # check for position, color in (((0, 0), self.red), ((10, 10), self.black), ((20, 20), self.black), ((40, 40), self.red)): fetched_color = RSDL_helper.get_pixel(self.dst_surf, position[0], position[1]) assert fetched_color == color
def test_bit_pattern(self): HEIGHT = WIDTH = 10 fmt = self.screen.c_format white = RSDL.MapRGB(fmt, 255, 255, 255) black = RSDL.MapRGB(fmt, 0, 0, 0) RSDL.LockSurface(self.screen) for i in xrange(WIDTH): for j in xrange(HEIGHT): k = j*WIDTH + i if k % 2: c = white else: c = black RSDL_helper.set_pixel(self.screen, i, j, c) RSDL.UnlockSurface(self.screen) RSDL.Flip(self.screen) self.check("Upper left corner 10x10 field with vertical black/white stripes")
def create_screen(self): if constants.USE_RSDL: self.screen = RSDL.SetVideoMode(self.width*self.scale, self.height*self.scale, 32, 0) fmt = self.screen.c_format self.colors = [] for color in self.COLOR_MAP: color = RSDL.MapRGB(fmt, *color) self.colors.append(color) self.blit_rect = RSDL_helper.mallocrect(0, 0, self.scale, self.scale)
def test_set_color_key(self): # prepare fillrect = RSDL_helper.mallocrect(10, 10, 30, 30) RSDL.FillRect(self.src_surf, fillrect, self.blue) lltype.free(fillrect, flavor='raw') assert RSDL.SetColorKey(self.src_surf, RSDL.SRCCOLORKEY, self.blue) == 0 # draw RSDL_helper.blit_complete_surface(self.src_surf, self.dst_surf, 0, 0) # check for position, color in ( (( 0, 0), self.red), ((10,10), self.black), ((20,20), self.black), ((40,40), self.red) ): fetched_color = RSDL_helper.get_pixel(self.dst_surf, position[0], position[1]) assert fetched_color == color
def test_set_alpha(self): # prepare assert RSDL.SetAlpha(self.src_surf, RSDL.SRCALPHA, 128) == 0 # draw RSDL_helper.blit_complete_surface(self.src_surf, self.dst_surf, 10, 10) RSDL_helper.blit_complete_surface(self.src_surf, self.dst_surf, 20, 20) # check for position, color in ( ((0, 0), (0, 0, 0)), # no rect ((10, 10), (127, 0, 0)), # one rect ((20, 20), (191, 0, 0)) # two overlapping rects ): fetched_color = RSDL_helper.get_pixel(self.dst_surf, position[0], position[1]) assert RSDL_helper.get_rgb(fetched_color, self.dst_surf.c_format) == color
def test_image_pixels(): for filename in ["demo.jpg", "demo.png"]: image = RIMG.Load(os.path.join(autopath.this_dir, filename)) assert image assert rffi.getintfield(image.c_format, 'c_BytesPerPixel') in (3, 4) RSDL.LockSurface(image) result = {} try: rgb = lltype.malloc(rffi.CArray(RSDL.Uint8), 3, flavor='raw') try: for y in range(23): for x in range(y % 13, 17, 13): color = RSDL_helper.get_pixel(image, x, y) RSDL.GetRGB(color, image.c_format, rffi.ptradd(rgb, 0), rffi.ptradd(rgb, 1), rffi.ptradd(rgb, 2)) r = rffi.cast(lltype.Signed, rgb[0]) g = rffi.cast(lltype.Signed, rgb[1]) b = rffi.cast(lltype.Signed, rgb[2]) result[x, y] = r, g, b finally: lltype.free(rgb, flavor='raw') finally: RSDL.UnlockSurface(image) RSDL.FreeSurface(image) for x, y in result: f = (x*17 + y*23) / float(17*17+23*23) expected_r = int(255.0 * (1.0-f)) expected_g = 0 expected_b = int(255.0 * f) r, g, b = result[x, y] assert abs(r-expected_r) < 10 assert abs(g-expected_g) < 10 assert abs(b-expected_b) < 10
def test_set_alpha(self): # prepare assert RSDL.SetAlpha(self.src_surf, RSDL.SRCALPHA, 128) == 0 # draw RSDL_helper.blit_complete_surface( self.src_surf, self.dst_surf, 10, 10) RSDL_helper.blit_complete_surface( self.src_surf, self.dst_surf, 20, 20) # check for position, color in ( (( 0, 0), ( 0,0,0)), # no rect ((10,10), (127,0,0)), # one rect ((20,20), (191,0,0)) # two overlapping rects ): fetched_color = RSDL_helper.get_pixel(self.dst_surf, position[0], position[1]) assert RSDL_helper.get_rgb(fetched_color, self.dst_surf.c_format) == color
def draw_pixels(self): for x in range(self.width): for y in range(self.height): RSDL_helper.set_pixel(screen, x, y, self.get_pixel_color(x, y))
def __init__(self): start = float(time.time()) self._neurons = [] self._columns = [] self._layers = [[]] * LAYERS self._pulse_layers = [0] * LAYERS self._pulse_layers[0] = 1 self._pulse_columns = [0] * COLUMNS self._pulse_columns[0] = 1 self._pulse_columns[1] = 1 self._pulse_columns[2] = 1 self._pulse_columns[3] = 1 inc = 360.0 / COLUMNS scale = float(LAYERS) expansion = 1.333 linc = scale / LAYERS for column in range(COLUMNS): colNeurons = [] self._columns.append(colNeurons) X = math.sin(radians(column * inc)) Y = math.cos(radians(column * inc)) expanding = STEM width = 1.0 / scale for layer in range(LAYERS): Z = layer * linc r = random() * random() g = 0.2 b = 0.2 for i in range(int(expanding)): x = uniform(-width, width) rr = random() * random() # DJ's trick y = uniform(-width * rr, width * rr) + X z = Z + Y # create 50/50 exitatory/inhibitory n = RecurrentSpikingModel(x=x, y=y, z=z, column=column, layer=layer, red=r, green=g, blue=b) self._neurons.append(n) colNeurons.append(n) self._layers[layer].append(n) expanding *= expansion width *= expansion dendrites = 0 interlayer = 0 for lay in self._layers: for a in lay: for b in lay: if a is not b and a._column == b._column: a.attach_dendrite(b) dendrites += 1 interlayer += 1 intercol = 0 for col in self._columns: for a in col: for b in col: if a is not b and random() * random() > 0.75: a.attach_dendrite(b) intercol += 1 dendrites += 1 intercore = 0 core = self._layers[-1] for a in core: for b in core: if a is not b and random() * random() > 0.85: a.attach_dendrite(b) intercore += 1 dendrites += 1 print 'brain creation time (seconds)', float(time.time()) - start print 'neurons per column', len(self._columns[0]) print 'inter-layer dendrites', interlayer print 'inter-column dendrites', intercol print 'inter-neocoretex dendrites', intercore print 'total dendrites', dendrites print 'total neurons', len(self._neurons) for i, lay in enumerate(self._layers): print 'layer: %s neurons: %s' % (i, len(lay)) for i, col in enumerate(self._columns): print 'column: %s neurons: %s' % (i, len(col)) self._stdin = streamio.fdopen_as_stream(0, 'r', 1) #self._stdout = streamio.fdopen_as_stream(1, 'w', 1) #self._stderr = streamio.fdopen_as_stream(2, 'w', 1) self._width = 640 self._height = 480 assert RSDL.Init(RSDL.INIT_VIDEO) >= 0 self.screen = RSDL.SetVideoMode(self._width, self._height, 32, 0) assert self.screen fmt = self.screen.c_format self.ColorWhite = white = RSDL.MapRGB(fmt, 255, 255, 255) self.ColorGrey = grey = RSDL.MapRGB(fmt, 128, 128, 128) self.ColorBlack = black = RSDL.MapRGB(fmt, 0, 0, 0) self.ColorBlue = blue = RSDL.MapRGB(fmt, 0, 0, 200) colors = {'white': white, 'grey': grey, 'black': black, 'blue': blue} x = 1 y = 1 for i, n in enumerate(self._neurons): braneRect = RSDL_helper.mallocrect(x, y, 12, 12) groupRect = RSDL_helper.mallocrect(x, y, 12, 2) spikeRect = RSDL_helper.mallocrect(x + 4, y + 4, 4, 4) n.setup_draw(self.screen.c_format, braneRect, groupRect, spikeRect, colors) x += 13 if x >= self._width - 14: x = 1 y += 13
def black(screen, cola, colb): for i in xrange(WIDTH): for j in xrange(HEIGHT): RSDL_helper.set_pixel(screen, i, j, cola)
def __init__(self): start = float(time.time()) self._neurons = [] self._columns = [] self._layers = [ [] ] * LAYERS self._pulse_layers = [0] * LAYERS self._pulse_layers[ 0 ] = 1 self._pulse_columns = [0] * COLUMNS self._pulse_columns[ 0 ] = 1 self._pulse_columns[ 1 ] = 1 self._pulse_columns[ 2 ] = 1 self._pulse_columns[ 3 ] = 1 inc = 360.0 / COLUMNS scale = float( LAYERS ) expansion = 1.333 linc = scale / LAYERS for column in range(COLUMNS): colNeurons = [] self._columns.append( colNeurons ) X = math.sin( radians(column*inc) ) Y = math.cos( radians(column*inc) ) expanding = STEM width = 1.0 / scale for layer in range(LAYERS): Z = layer * linc r = random() * random() g = 0.2 b = 0.2 for i in range(int(expanding)): x = uniform( -width, width ) rr = random()*random() # DJ's trick y = uniform( -width*rr, width*rr ) + X z = Z + Y # create 50/50 exitatory/inhibitory n = RecurrentSpikingModel(x=x, y=y, z=z, column=column, layer=layer, red=r, green=g, blue=b ) self._neurons.append( n ) colNeurons.append( n ) self._layers[ layer ].append( n ) expanding *= expansion width *= expansion dendrites = 0 interlayer = 0 for lay in self._layers: for a in lay: for b in lay: if a is not b and a._column == b._column: a.attach_dendrite( b ) dendrites += 1 interlayer += 1 intercol = 0 for col in self._columns: for a in col: for b in col: if a is not b and random()*random() > 0.75: a.attach_dendrite( b ) intercol += 1 dendrites += 1 intercore = 0 core = self._layers[-1] for a in core: for b in core: if a is not b and random()*random() > 0.85: a.attach_dendrite( b ) intercore += 1 dendrites += 1 print 'brain creation time (seconds)', float(time.time())-start print 'neurons per column', len(self._columns[0]) print 'inter-layer dendrites', interlayer print 'inter-column dendrites', intercol print 'inter-neocoretex dendrites', intercore print 'total dendrites', dendrites print 'total neurons', len(self._neurons) for i,lay in enumerate(self._layers): print 'layer: %s neurons: %s' %(i,len(lay)) for i,col in enumerate(self._columns): print 'column: %s neurons: %s' %(i,len(col)) self._stdin = streamio.fdopen_as_stream(0, 'r', 1) #self._stdout = streamio.fdopen_as_stream(1, 'w', 1) #self._stderr = streamio.fdopen_as_stream(2, 'w', 1) self._width = 640; self._height = 480 assert RSDL.Init(RSDL.INIT_VIDEO) >= 0 self.screen = RSDL.SetVideoMode(self._width, self._height, 32, 0) assert self.screen fmt = self.screen.c_format self.ColorWhite = white = RSDL.MapRGB(fmt, 255, 255, 255) self.ColorGrey = grey = RSDL.MapRGB(fmt, 128, 128, 128) self.ColorBlack = black = RSDL.MapRGB(fmt, 0, 0, 0) self.ColorBlue = blue = RSDL.MapRGB(fmt, 0, 0, 200) colors = {'white':white, 'grey':grey, 'black':black, 'blue':blue} x = 1; y = 1 for i,n in enumerate(self._neurons): braneRect = RSDL_helper.mallocrect(x, y, 12, 12) groupRect = RSDL_helper.mallocrect(x, y, 12, 2) spikeRect = RSDL_helper.mallocrect(x+4, y+4, 4, 4) n.setup_draw( self.screen.c_format, braneRect, groupRect, spikeRect, colors ) x += 13 if x >= self._width-14: x = 1 y += 13