def plot_coeffs(coeffs): rcParams['figure.figsize'] = get_dims() fig, ax1 = plt.subplots() toplot = dict(x=[], y1=[], y2=[]) for domain in sorted(coeffs.keys(), key=lambda x: float(x)): toplot['x'].append(float(domain)) toplot['y1'].append(coeffs[domain][1]) toplot['y2'].append(coeffs[domain][2]) ax1.plot(toplot['x'], toplot['y1'], marker='o', color=hsv_to_rgb(0, 0.7, 0.9), label='$b_1$') plt.subplots_adjust(bottom=0.3, left=0.20) ax1.set_yscale('log') ax1.set_xlabel('Domain size/$\pi$') savefig('b1_vs_domain.png', dpi=600) fig, ax2 = plt.subplots() ax2.plot(toplot['x'], toplot['y2'], marker='o', color=hsv_to_rgb(0.5, 0.7, 0.9), label='$b_2$') ax2.set_xlabel('Domain size/$\pi$') plt.subplots_adjust(bottom=0.3) savefig('b2_vs_domain.png', dpi=600)
def Retina(self, properties): input_generator=self['training_patterns'][properties['eye']+'Retina' if 'eye' in properties else 'Retina'] if 'cr' in self.dims and self.dataset!='Gaussian': for pattern_number, individual_generator in enumerate(input_generator.generators): brightness_difference=numbergen.UniformRandom(lbound=(-1.0+self.dim_fraction)/2.0, ubound=(1.0-self.dim_fraction)/2.0, seed=456+pattern_number, name="Dim"+str(pattern_number)) if 'eye' in properties and properties['eye']=='Left': hsv = colorsys.rgb_to_hsv(*self.cone_scale) hsv_dimmed=(hsv[0],hsv[1],hsv[2]+brightness_difference) channel_factors = list(colorsys.hsv_to_rgb(*hsv_dimmed)) elif 'eye' in properties and properties['eye']=='Right': hsv = colorsys.rgb_to_hsv(*self.cone_scale) hsv_dimmed=(hsv[0],hsv[1],hsv[2]-brightness_difference) channel_factors = list(colorsys.hsv_to_rgb(*hsv_dimmed)) else: channel_factors = self.cone_scale individual_generator.channel_transforms.append( ScaleChannels(channel_factors = channel_factors)) return Model.ChannelGeneratorSheet.params( period=self['period'], phase=0.05, nominal_density=self.retina_density, nominal_bounds=sheet.BoundingBox(radius=self.area/2.0 + self.v1aff_radius*self.sf_spacing**(max(self['SF'])-1) + self.lgnaff_radius*self.sf_spacing**(max(self['SF'])-1) + self.lgnlateral_radius), input_generator=input_generator)
def step(self): def maxat(a): return max(enumerate(a), key=lambda x: x[1])[0] #self.read_midi_events() audio, fft = self.analyze_audio() self.write_spectrum(fft) mind = self.inp(24, 4) dom_chk = maxat(fft[mind:-mind]) + mind dom_freq = self.RATE * dom_chk / self.CHUNK #self.dom_freq = dom_freq dom_freq = self.smooth("dom_freq", dom_freq, self.inp(14, 10) / 500.0) #sys.stdout.write("\rdom_freq %d" % dom_freq) octave = 2.0 ** math.floor(math.log(dom_freq) / math.log(2)) self.octave = octave self.hue = ((dom_freq - octave) / octave + self.hueoff) self.hue += self.inp(14, 0) / 127.0 self.hue = self.hue % 1.0 self.lpf_audio=[self.lpf(float(data),mem,self.alpha) for data,mem in zip(audio,self.lpf_audio)] self.history.append(self.lpf_audio) if len(self.history)>self.HISTORY_SIZE: self.history.popleft() scaling_factor=[max(max([d[j] for d in self.history]),1) for j in range(len(self.RANGES))] levels=[a/f for a,f in zip(self.lpf_audio,scaling_factor)] bass_val = max(min((levels[0]-0.1)/0.9,1.), 0.0) bass_val = self.smooth("bass_val", bass_val, 0.6) bass_hue = (self.hue + 0.95) % 1.0 if bass_val < 0.1: # Switch colors for low bass values bass_hue = (bass_hue + 0.9) % 1.0 bass_val *= 1.1 bass_val = max(bass_val ** 0.9 , 0.1) bass_color=self.makecolor(colorsys.hsv_to_rgb(bass_hue,1. * self.whiteout,bass_val * self.mute)) treble_color=self.makecolor(colorsys.hsv_to_rgb(self.hue,0.7 * self.whiteout,1. * self.mute)) #treble_size = (0.5-0.3*levels[1]) #treble_size = self.smooth("treble_size", levels[1], 0.3) treble_size = levels[1] self.mute += self.mute_delta self.mute = max(min(self.mute, 1.0), 0.0) self.whiteout += self.whiteout_delta #self.whiteout = max(min(self.whiteout, 1.0), 0.0) self.mute = self.inp(11, 0) / 127.0 self.update_strip([ #self.solid_color(bass_color, alpha=0xff, id=0x00), (0x10, 0x00)+bass_color+(0xFF,), (0x05,0x01)+treble_color+(0xFF,self.makebyte(self.STRIP_LENGTH*(0.5-0.3*treble_size)),self.makebyte(self.STRIP_LENGTH*(0.5+0.3*treble_size))), #self.vu_stripe(treble_color, 0.5 - 0.3 * treble_size, 0.5 + 0.3 * treble_size), #(0x05,0x02,0x00,0xFF,0xFF,0xFF,self.makebyte(self.STRIP_LENGTH*(0.5-0.2*levels[2])),self.makebyte(self.STRIP_LENGTH*(0.5+0.2*levels[2]))), ])
def hsv_rgba(c, astype=0): if astype == AS_INT: color = colorsys.hsv_to_rgb(c[0], c[1], c[2]) color = (color[0], color[1], color[2], 1) return rgb_to_int(color) color = colorsys.hsv_to_rgb(c[0], c[1], c[2]) return (color[0], color[1], color[2], 1)
def execute_fit(): fits = gen_fits(0.3, 0.1) print fits[24][1.04] rcParams['figure.figsize'] = 4.981320049813201, 4 gs = gridspec.GridSpec(5, 1) gs.update(wspace=0) ax1 = plt.subplot(gs[:4, 0]) ax2 = plt.subplot(gs[4, 0], sharex=ax1) coefficients = {} for n, domain in enumerate(sorted(fits.keys(), key=lambda x: float(x))): if domain == 10: continue curr_keys = sorted(fits[domain].keys(), key=lambda x: float(x)) x = map(lambda x: float(x), curr_keys) y = map(lambda x: fits[domain][x]['avg'][1], curr_keys) with open('domain_' + str(domain), 'w') as f: for i,R in enumerate(x): f.write("%f %f\n" % (R, y[i])) try: popt, pcov = opt.curve_fit(model_function, np.array(x), np.array(y), (0.5324, -0.0090589, 6.2374), maxfev=100000) coefficients[domain] = popt except RuntimeError: continue color1 = hsv_to_rgb(float(n) / len(fits.keys()), 0.7, 0.9) color2 = hsv_to_rgb(float(n + 1) / len(fits.keys()), 0.7, 0.9) if int(domain)%4 == 0 and int(domain) != 20: ax1.plot(x, y, label='Data at %s$\pi$' % (domain), color=color1) ax1.plot(x, [model_function(x_val, *popt) for x_val in x], label='Fit at %s$\pi$' % (domain), color=color2) if domain == 24: values = [model_function(x_val, *popt) for x_val in x] residuals = map(lambda x: abs(x[0] - x[1]) / x[0], zip(y, values)) ax2.plot(x, residuals, marker='o') ax2.set_yscale('log') ax1.legend(loc=0) ax1.xaxis.set_visible(False) ax2.set_xlabel('R') ax1.set_ylabel('Value of $a_1$') ax2.set_ylabel('Residue\nat 24$\pi$') ax2.yaxis.tick_right() plt.subplots_adjust(bottom=0.15) savefig('double_exp_fit.png', dpi=600) plot_coeffs(coefficients)
def ccolor (cluster): rnd.seed(cluster) hue = rnd.random() val = rnd.uniform(0.3,0.7) fill = colorsys.hsv_to_rgb(hue, 0.5, val) border = colorsys.hsv_to_rgb(hue, 1, val) return (fill, border)
def local_ip_to_rgb(ip): ipa = ip.split('.') if ipa: last = ipa.pop() if last in DEVICE_COLOURS: return colorsys.hsv_to_rgb(DEVICE_COLOURS[last] / 360.0, 1, VALUE) return colorsys.hsv_to_rgb(1, 0, VALUE)
def main(argv): w = Wall(24,17) while True: rgb = colorsys.hsv_to_rgb(random.random(), 1, intensity) color = [int(rgb[0]*255), int(rgb[1]*255), int(rgb[2]*255)] up=True for i in range(0,len(w.sticks)/2): x1 = len(w.sticks)-1-i x2 = i print("Updating " + str(x1) + " and " + str(x2)) for y in range(59*(not up),60*up, -1+(2*up) ): w.sticks[x1].setLed(y+1, *color) w.sticks[x1].updateLeds() w.sticks[x2].setLed(y+1, *color) w.sticks[x2].updateLeds() time.sleep(0.005) up=not up rgb = colorsys.hsv_to_rgb(random.random(), 1, intensity) color = [int(rgb[0]*255), int(rgb[1]*255), int(rgb[2]*255)] for i in range(0,len(w.sticks)/2): z1 = (len(w.sticks)/2) - i - 1 z2 = (len(w.sticks)/2) + i for x in range(59*(not up),60*up, -1+(2*up) ): w.sticks[z1].setLed(x+1, *color) w.sticks[z1].updateLeds() w.sticks[z2].setLed(x+1, *color) w.sticks[z2].updateLeds() time.sleep(0.005) up=not up
def create_image(): img = Image.new( 'RGB', (1000,1000), "black") # create a new black image pixels = img.load() # create the pixel map for i in range(img.size[0]): # for every pixel: for j in range(img.size[1]): if(board[i][j]==float("Inf")): continue if(board[i][j]==10000000): print "player1" pixels[i,j] = (player1[0]*255,player1[1]*255,player1[2]*255) elif(board[i][j]==-10000000): print "player2" pixels[i,j] = (player2[0]*255,player2[1]*255,player2[2]*255) elif(board[i][j]>0): p_color = colorsys.rgb_to_hsv(player1_area[0], player1_area[1], player1_area[2]) value = [p_color[0],p_color[1],p_color[2]] value[1] = math.sqrt(math.sqrt(math.sqrt(abs(board[i][j])))) value = colorsys.hsv_to_rgb(value[0], value[1], value[2]) pixels[i,j] = (int(value[0]*255),int(value[1]*255),int(value[2]*255)) # set the colour accordingly elif(board[i][j]<0): p_color = colorsys.rgb_to_hsv(player2_area[0], player2_area[1], player2_area[2]) value = [p_color[0],p_color[1],p_color[2]] value[1] = math.sqrt(math.sqrt(math.sqrt(abs(board[i][j])))) value = colorsys.hsv_to_rgb(value[0], value[1], value[2]) pixels[i,j] = (int(value[0]*255),int(value[1]*255),int(value[2]*255)) # set the colour accordingly else: pixels[i,j] = background img.save('board.gif')
def phase_to_rgb(phase): frac = (phase + n.pi) / (2*n.pi) rgb = [min(255, int(j*255)) for j in hsv_to_rgb(frac, 1, 1)] return rgb return [val,val,val] colour = list(hsv_to_rgb(frac,1,1)) return map(lambda j: int(j*255),colour)
def updateDamage(self): # recolor the percentage old_redness = self.redness self.redness = min(1.0, float(self.percent) / 300) # the lighter color first rgb_from = tuple(int(i * 255) for i in colorsys.hsv_to_rgb(0, old_redness, 1.0)) rgb_to = tuple(int(i * 255) for i in colorsys.hsv_to_rgb(0, self.redness, 1.0)) self.percent_sprites.recolor(self.percent_sprites.sheet, rgb_from, rgb_to) # the darker color next rgb_from = tuple(int(i * 255) for i in colorsys.hsv_to_rgb(0, old_redness, 0.785)) rgb_to = tuple(int(i * 255) for i in colorsys.hsv_to_rgb(0, self.redness, 0.785)) self.percent_sprites.recolor(self.percent_sprites.sheet, rgb_from, rgb_to) self.percent_sprite.image = pygame.Surface((196, 64), pygame.SRCALPHA, 32).convert_alpha() percent_string = str(int(self.percent)) # converting it to a string so we can iterate over it. length = 0 for ch in percent_string: i = int(ch) self.percent_sprite.image.blit(self.percent_sprites.getImageAtIndex(i), (length, 0)) length += self.kerning_values[i] # add the % sign at the end self.percent_sprite.image.blit(self.percent_sprites.getImageAtIndex(10), (length, 0)) self.percent_sprite.image = pygame.transform.smoothscale(self.percent_sprite.image, (96, 32)) length += self.kerning_values[10]
def generate(im_width, im_height, text, img_scale, fontfile, jpg_quality, hsv_color): """Create a new jpg file. Render the text, in the middle Adjust the font size to utilize the space """ text = str(text).replace("\n", "").strip() new_image = Image.new("RGB", (im_width, im_height), (0, 0, 0)) draw = ImageDraw.Draw(new_image) fontsize = 1 font = ImageFont.truetype(fontfile, fontsize) text_width, text_height = font.getsize(text) while (text_width < img_scale*im_width and text_height < img_scale * im_height) : fontsize += 1 font = ImageFont.truetype(fontfile, fontsize) text_width, text_height = font.getsize(text) font = ImageFont.truetype(fontfile, fontsize-1) if hsv_color[0]==-1: color = colorsys.hsv_to_rgb(random(), hsv_color[1], hsv_color[2]) else: color = colorsys.hsv_to_rgb(hsv_color[0], hsv_color[1], hsv_color[2]) color_rgb = tuple([int(256*x) for x in color]) draw.text(((im_width-text_width) / 2, (im_height-text_height) / 2), text, fill = (color_rgb), font=font) filename = text.translate(string.maketrans("",""), string.punctuation)+".jpg" new_image.save(filename, "jpeg",quality=jpg_quality) print filename
def main(argv): w = Wall(24,17) while True: colx = random.random() print(colx) color = colorsys.hsv_to_rgb(colx, 1, 0.20) print(color[1]) for i in range(0,len(w.sticks)): x = len(w.sticks)-1-i w.sticks[x].setAllLeds(int(color[0]*255),int(color[1]*255),int(color[2]*255)) time.sleep(0.04) while True: col = random.random() if col+0.45 < colx or col-0.45 > colx: break print("reroll") print("reroll") print("reroll") print("reroll") print("reroll") print("reroll") print("reroll") print("reroll") print(col) color = colorsys.hsv_to_rgb(col, 1, 0.5) print(color[1]) for i in range(0,len(w.sticks)): w.sticks[i].setAllLeds(int(color[0]*255),int(color[1]*255),int(color[2]*255)) time.sleep(0.04)
def __init__(self, world): self.world = world self.radius = 5 x = random.randint(int(world.window.width*0.05),int(world.window.width*0.95)) y = random.randint(int(world.window.height*0.05),int(world.window.height*0.95)) ps.Group.__init__(self, x=x, y=y) self.rect = ps.Rect(x=-self.radius,y=-self.radius,width=10,height=10, color=(0,1,0,1)) self.call_to_action = ps.Rect(x=-self.radius*2,y=-self.radius*2,width=20,height=20, color=(0,0,0,0),stroke_color=(0,1,0,1), stroke_thickness=1) if random.random()>0.5: self.rect.color.values = colorsys.hsv_to_rgb(0.9,1,1) # Blue self.call_to_action.stroke_color.values = colorsys.hsv_to_rgb(0.9,1,1) self.type = "B" else: self.rect.color.values = colorsys.hsv_to_rgb(0.3,1,1) # Green self.call_to_action.stroke_color.values = colorsys.hsv_to_rgb(0.3,1,1) self.type = "G" self.add(self.rect) self.add(self.call_to_action) self.remove_me = False
def plot_avg(): maxlen = -1 for filename in glob('/tmp/e-02/process0-output*'): with open(filename) as f: length = len(f.readlines()) if length > maxlen: maxlen = length for filename in glob('/tmp/e-05/process0-output*'): with open(filename) as f: length = len(f.readlines()) if length > maxlen: maxlen = length second = get_avg('/tmp/e-02/', maxlen) fifth = get_avg('/tmp/e-05/', maxlen) color1 = hsv_to_rgb(0, 0.7, 0.9) color2 = hsv_to_rgb(0.5, 0.7, 0.9) fig, ax = plt.subplots() ax.plot(fifth['x'], fifth['y'], label='$\lambda=10^{-5}$', color=color2) ax.plot(second['x'], second['y'], alpha=0.8, label='$\lambda=10^{-2}$', color=color1) ax.set_xscale('log') ax.set_yscale('log') ax.legend(loc=0) plt.subplots_adjust(bottom=0.15) ax.set_xlabel('frequency') savefig('fourier.png', dpi=600)
def css(count): grad_top = hsv_to_rgb(0.3 * count / projects.count(), 0.9, 0.5) grad_bottom = hsv_to_rgb(0.3 * count / projects.count(), 0.9, 0.9) border = hsv_to_rgb(0.3 * count / projects.count(), 0.9, 0.7) return """ background:rgb({3},{4},{5}); background-image: -webkit-gradient(linear, left bottom, left top, from(rgb({0},{1},{2})), to(rgb({3},{4},{5}))); background-image: -moz-linear-gradient(100% 100% 90deg, rgb({0},{1},{2}), rgb({3},{4},{5}) ); border: 1px solid rgb({6},{7},{8}); width:{9}px;display: block;""".format( int(grad_top[0] * 255), int(grad_top[1] * 255), int(grad_top[2] * 255), int(grad_bottom[0] * 255), int(grad_bottom[1] * 255), int(grad_bottom[2] * 255), int(border[0] * 255), int(border[1] * 255), int(border[2] * 255), int(424 * (1.0 * count / projects.count())) )
def build_stops(hues, sat, rval): # {{{ from colorsys import hsv_to_rgb nstops = len(hues) + 1 stops = [dict(s=S) for S in np.linspace(0, 1, nstops)] flipped = False j = [0, 1] for i, h in enumerate(hues): r1, g1, b1 = hsv_to_rgb(np.fabs(h), sat[j[0]], rval[j[0]]) r2, g2, b2 = hsv_to_rgb(np.fabs(h), sat[j[1]], rval[j[1]]) if h < 0.: if flipped: r1, g1, b1 = 1., 1., 1. else: r2, g2, b2 = 1., 1., 1. j = [1, 0] flipped = True if i == 0: stops[i].update(dict(r=r1, g=g1, b=b1)) else: stops[i].update(dict(r2=r1, g2=g1, b2=b1)) stops[i+1].update(dict(r=r2, g=g2, b=b2)) return stops
def SetColorsPerChr(self, boGreyScale=bool, NChr=int): HSV_tuples = None RGB_tuples = None if(boGreyScale): boGrey = True GreyHSV = (0.0,0.0,0.4) BlackHSV = (0.0,0.0,0.0) HSV_tuples = [] for i in range(NChr): if(boGrey): HSV_tuples.append(GreyHSV) boGrey = False else: HSV_tuples.append(BlackHSV) boGrey = True RGB_tuples = map(lambda x: colorsys.hsv_to_rgb(*x), HSV_tuples) else: HSV_tuples = [(x*1.0/NChr, 0.75, 0.75) for x in range(NChr)] RGB_tuples = map(lambda x: colorsys.hsv_to_rgb(*x), HSV_tuples) self.RGBTupleDict = {} for i in range(len(RGB_tuples)): Tuple = RGB_tuples[i] Chr = str(i+1) self.RGBTupleDict[Chr] = Tuple return
def draw(self): background(0, 0, 0) last_beat = int(self.beat) self.beat += 1.0/7.5 self.beat %= 16 play = int(self.beat) != last_beat for y in xrange(16): beat_row = int(self.beat) == y for x in xrange(8): if self.grid[x][y]: h = x / 8.0 r, g, b = hsv_to_rgb(h, 1, 1) if play and int(self.beat) == y: play_effect(self.sounds[x]) if beat_row: h = x / 8.0 r, g, b = hsv_to_rgb(h, 1, 1) fill(r, g, b) else: r, g, b = hsv_to_rgb(h, 1, 0.5) fill(r, g, b) elif beat_row: fill(1, 1, 1) else: fill(0.50, 0.50, 0.50) rect(x*(self.bounds.w/4), y*(self.bounds.h/9), self.bounds.w/4, self.bounds.h/9)
def writeOut(): global prevs, envPrevs, envLo, envHi now = time.time() envPrevs = (envPrevs + [currentLevel])[-50:] prevs = (prevs + [currentLevel])[-config['avgPrevs']:] avg = sum(prevs) / len(prevs) yEnv = max(0, avg - envLo) / (envHi - envLo) envLo = min(envPrevs) envHi = max(envPrevs) y = max(0, min(1, (yEnv + config['levelOffset']) / config['levelMax'])) y = math.pow(y, config['gamma']) if y > .8 and now > state['lastHueTime'] + .3: state['dominantHue'] = .5 - state['dominantHue']#random.random() state['lastHueTime'] = time.time() print "hue", state['dominantHue'] chans = [0] * 90 h = state['dominantHue'] + y / 5 chans[73-1:76-1] = list(colorsys.hsv_to_rgb(h, 1, y)) chans[80-1:83-1] = list(colorsys.hsv_to_rgb(h, 1, y)) chans[88-1:91-1] = list(colorsys.hsv_to_rgb(h, .4, y)) # center chans[87-1] = .84 dmxclient.outputlevels(chans, twisted=True)
def __set_gradient_pattern(self, cr, tx, ty): # use gray if no color is given r1, g1, b1 = 0.2, 0.2, 0.2 r2, g2, b2 = 0.8, 0.8, 0.8 if self.color: r, g, b = self.color r, g, b = float(r)/255, float(g)/255, float(b)/255 h, s, v = colorsys.rgb_to_hsv(r, g, b) r1, g1, b1 = colorsys.hsv_to_rgb(h, s, min(v+0.2, 1.0)) h, s, v = colorsys.rgb_to_hsv(r, g, b) r2, g2, b2 = colorsys.hsv_to_rgb(h, s, max(v-0.2, 0)) if self.gradient_direction == 1: pat = cairo.LinearGradient(0.0, 0.0, 0.0, 200.0-ty) elif self.gradient_direction == 2: pat = cairo.LinearGradient(0.0, 200.0-ty, 0.0, 0.0) elif self.gradient_direction == 3: pat = cairo.LinearGradient(0.0, 0.0, 200.0-tx, 0.0) else: pat = cairo.LinearGradient(200.0-tx, 0.0, 0.0, 0.0) pat.add_color_stop_rgba(0, r2, g2, b2, 0.8) pat.add_color_stop_rgba(1, r1, g1, b1, 0.8) cr.set_source(pat)
def uni_show(prev_x, prev_y): a = np.random.rand(1) b = np.random.rand(1) c = np.random.rand(1) rgb_on = colorsys.hsv_to_rgb(a, b, c) rgb_off = colorsys.hsv_to_rgb(0.5, 0.5, 0.1) r_on = int(rgb_on[0]*255.0) g_on = int(rgb_on[1]*255.0) b_on = int(rgb_on[2]*255.0) r_off = int(rgb_off[0]*255.0) g_off = int(rgb_off[1]*255.0) b_off = int(rgb_off[2]*255.0) a = np.random.rand(1) x = int(a[0] * 8)-1 b = np.random.rand(1) y = int(b[0] * 8)-1 #print x, y if x < 0: x = 0 if y < 0: y = 0 unicorn.set_pixel(x, y, r_on, g_on, b_on) unicorn.set_pixel(prev_x, prev_y, r_off, g_off, b_off) unicorn.show() return x, y
def gen_surv_plot(): with open('24-1.05-survival_probability') as f: points = map(lambda x: (float(x.split(' ')[0]), float(x.split(' ')[1])), f.readlines()) fits = gen_fits(0.1, 0.1) a0, a1= fits[24][1.05]['avg'] color1 = hsv_to_rgb(0, 0.7, 0.9) color2 = hsv_to_rgb(0.5, 0.7, 0.9) fig, ax = plt.subplots() ax.plot(map(lambda x: x[0], points), map(lambda x: x[1], points), label="Data", marker=',', color=color1) ax.plot(map(lambda x: x[0], points), map(lambda x: model_function(x, a0, a1), map(lambda x: x[0], points)), label="Fit", color=color2, alpha=0.7) #plt.title('Data and fit at R=1.06') ax.legend(loc=0) ax.set_ylabel('$S(t)$') ax.set_xlabel('$t$') ax.set_xlim([0, 7000]) plt.hlines(0.1, 0, 7000, linestyles='dashed') plt.text(5000, 0.11, 'Fit threshold') plt.subplots_adjust(bottom=0.15) savefig('surv_prob.png', dpi=600)
def plot_portrait(): with open('/tmp/e-02/process0-output16') as f: lines = f.readlines() pos02 = map(lambda y: map(lambda x: float(x), y.split(' ')[:3]), filter(lambda z: len(z.split(' ')) > 2, lines)) with open('/tmp/e-05/process0-output02') as f: lines = f.readlines() pos05 = map(lambda y: map(lambda x: float(x), y.split(' ')[:3]), filter(lambda z: len(z.split(' ')) > 2, lines)) fig, ax = plt.subplots() color1 = hsv_to_rgb(0, 0.7, 0.9) color2 = hsv_to_rgb(0.5, 0.7, 0.9) ax.plot(map(lambda x: x[1], pos02), map(lambda x: x[2], pos02), label='$\lambda=10^{-2}$', color=color1) ax.plot(map(lambda x: x[1], pos05), map(lambda x: x[2], pos05), label='$\lambda=10^{-5}$', color=color2, alpha=0.8) ax.legend(loc=0) ax.set_xlabel('l2 norm of $u(t)$') ax.set_ylabel('l2 norm of $v(t)$') plt.subplots_adjust(bottom=0.15) savefig('phase.png', dpi=600)
def circle(self, cr, matrix, number, angle, scale, distance, fill_hue, fill_hue_incr, stroke_hue, stroke_hue_incr, depth, max_depth): if depth >= max_depth: return cr.set_matrix(matrix) cr.arc(0, 0, 100, 0, 2*math.pi) stroke_color = colorsys.hsv_to_rgb(stroke_hue, 0.5, 0.2) cr.set_source_rgb(stroke_color[0], stroke_color[1], stroke_color[2]) cr.set_line_width(40) cr.stroke_preserve() fill_color = colorsys.hsv_to_rgb(fill_hue, 1, 1) cr.set_source_rgb(fill_color[0], fill_color[1], fill_color[2]) cr.fill() for i in range(number): cr.set_matrix(matrix) cr.rotate(angle*i) cr.translate(distance*100, 0) cr.scale(scale, scale) sub_matrix = cr.get_matrix() self.circle(cr, sub_matrix, number, angle, scale, distance, fill_hue+fill_hue_incr, fill_hue_incr, stroke_hue+stroke_hue_incr, stroke_hue_incr, depth+1, max_depth)
def draw(self): # speed defined here h = math.fmod(self.time / 3, 2) if h >= 1: h = 2 - h x = int(round(self.n)) offset = 1.0 / (len(self.text) + 1) self.canvas.clear(*hsv_to_rgb(h, 1, 0.03)) h = math.fmod(h + offset, 1) length = -1 for c in self.text: length += letters[c].width + 1 x = (width - length + 1) / 2 for c in self.text: r, g, b = hsv_to_rgb(h, 1, brightness) h = math.fmod(h + offset, 1) letter = letters[c] self.canvas.add_letter(letter, x, 0, r, g, b) x += letter.width + 1 if self.n > 15 or self.n < -15: self.d = not self.d
def draw_lissajous(a, b, h): t = np.arange(0, 16*np.pi, np.pi/1024) x = (159 * np.sin(a*t) + 159).astype(np.uint) y = (119 * np.cos(b*t) + 119).astype(np.uint) picture = np.zeros((320, 240, 3)) picture[:, :, :] = colorsys.hsv_to_rgb(h, 1.0, 1.0) picture[x, y, :] = np.array(colorsys.hsv_to_rgb((h+0.5)%1.0, 1.0, 1.0)) return picture
def __setRandomColours(self): '''Set the gradient and mouse hover colours using an aesthetically pleasing HSV colour palette. The same hue value is used for all colours with varying degrees of saturation to generate different shades.''' hue = randint(0, 360) / 360 self.tColour = tuple(i * 255 for i in hsv_to_rgb(hue, 0.6, 0.95)) self.bColour = tuple(i * 255 for i in hsv_to_rgb(hue, 1, 0.95)) self.hColour = tuple(i * 255 for i in hsv_to_rgb(hue, 0.05, 0.95))
def getColor(self,number): """Returns an HTML color with a certain level of black or red (depending on the sign of the numbre provided)""" if number >= 0: ret = cs.hsv_to_rgb(0,0,1-abs(number/self.maxp)) else: ret = cs.hsv_to_rgb(0,abs(number/self.maxn),1) hexcolor = '#%02x%02x%02x' % (ret[0]*255,ret[1]*255,ret[2]*255) return hexcolor
def on_value_change(value=self.slider.slider_color): value = rgb_to_hsv(self.slider.slider_color[0], self.slider.slider_color[1], self.slider.slider_color[2]) h, s, v = value[0], value[1], value[2] if self.slider._value <= 1.0: s = self.slider._value else: v = 2 - self.slider._value Observer.get("canvas").set_brush_color(hsv_to_rgb(h, s, v)) self.slider.slider_color = hsv_to_rgb(h, s, v)
def get_fingerprint_colors(base): return (normalise_tuple(colorsys.hsv_to_rgb(base, 0.4, 1.0), 255), normalise_tuple(colorsys.hsv_to_rgb(base, 0.4, 0.75), 255))
imgx, imgy = 512, 512 # IMAGE DIMENSIONS tmax = 256 # MAXIMUM ITERATIONS xa3, xb3 = -0.1475, -0.1425 ya3, yb3 = 0.255, 0.26 image = Image.new("RGB", (imgx, imgy)) # CREATES IMAGE ACCORDING TO DIMENSIONS cx, cy = -.79, .15 for x in range(imgx): for y in range(imgy): # Z starts at X,Y instead of 0,0 zx = (x * (xb3 - xa3) / (imgx - 1) + xa3) zi = (y * (yb3 - ya3) / (imgy - 1) + ya3) for t in range(tmax): # same equations as Mandelbrot absz = float(((zx**2) + (zi**2))**0.5) if absz >= 2.0: break zx, zi = float((zx * zx - zi * zi) + cx), float((zi * zx + zx * zi) + cy) # cycles through HSV starting from yellow R, G, B = int( colorsys.hsv_to_rgb( (0.297222 - (t / tmax)) % 1, 1, 1.36)[0] * 255), int( colorsys.hsv_to_rgb( (0.297222 - (t / tmax)) % 1, 1, 1.36)[1] * 255), int( colorsys.hsv_to_rgb( (0.297222 - (t / tmax)) % 1, 1, 1.36)[2] * 255) image.putpixel((x, imgy - 1 - y), (R, G, B)) image.save("julia.png")
def _random_colors(self, N, bright=True): hsv = [(float(i / N), 1, 1.0) for i in range(N)] colors = list(map(lambda c: colorsys.hsv_to_rgb(*c), hsv)) random.shuffle(colors) return colors
# create a palette for mapping heat values onto colours palette = [0] * 256 for i in range(0, 256): h = i / 5.0 h /= 360.0 s = (1.0 / (math.sqrt(i / 50.0) + 0.01)) s = min(1.0, s) s = max(0.0, s) v = i / 200.0 if i < 60: v = v / 2 v = min(1.0, v) v = max(0.0, v) r, g, b = colorsys.hsv_to_rgb(h, s, v) palette[i] = (int(r * 255.0), int(g * 255.0), int(b * 255.0)) def set_pixel(b, x, y, v): b[y * 16 + x] = int(v) # edited 16 to 8 def get_pixel(b, x, y): # out of range sample lookup if x < 0 or y < 0 or x >= 16 or y >= 16: # edited 16 to 8 return 0 # subpixel sample lookup if isinstance(x, float) and x < 7: # edited 15 to 7 f = x - int(x)
for i in range(28): # Write labels cell = sheet.cell(column=i + 2, row=1, value=sorted(char_map.keys())[i]) cell.alignment = Alignment(text_rotation=90, horizontal='center') sheet.cell(column=1, row=i + 2, value=sorted(char_map.keys())[i]) min_confusion = confusionmap[i][0:28].min() max_confusion = confusionmap[i][0:28].max() # write cell values for j in range(28): col = j + 2 row = i + 2 value = confusionmap[i][j] confusion = value / (max_confusion - min_confusion * 1.0) rgb = colorsys.hsv_to_rgb(hsv[0], confusion, hsv[2]) color = str(format(int(rgb[0] * 255), '02X')) + str( format(int(rgb[1] * 255), '02X')) + str( format(int(rgb[2] * 255), '02X')) cell = sheet.cell(column=col, row=row, value=value) cell.fill = PatternFill(fgColor=color, fill_type="solid") sheet.cell(column=1, row=1, value="real/predicted") sheet.cell(column=1, row=30, value="Sample size:").font = Font(bold=True) sheet.cell(column=3, row=30, value=str(len(imagePaths))).font = Font(bold=True) sheet.cell(column=1, row=31, value="Total loss:").font = Font(bold=True) sheet.cell(column=3, row=31, value=str(int(loss))).font = Font(bold=True)
if y > 1.9 and not direction == 1: direction = 1 t.append(millis() - t_start) t_start = millis() t = t[-5:] if len(t) > 0: total_time = float(sum(t)) / len(t) offset = ((millis() - t_start) / total_time) # offset += direction * 10 offset = min(1.0, offset) offset = max(0.0, offset) hue = offset if direction == -1: hue = 1.0 - offset r, g, b = [int(c * 255.0) for c in hsv_to_rgb(hue, 1.0, 1.0)] for x in range(8): blinkt.set_pixel(x, r, g, b) blinkt.show() time.sleep(0.0001)
def draw_boxes(image, boxes, scores, labels, classes, detection_size, font='./files/font/FiraMono-Medium.otf', show=True): if boxes is None: return image, False draw = ImageDraw.Draw(image) # draw settings font = ImageFont.truetype(font=font, size=np.floor(2e-2 * image.size[1]).astype('int32')) hsv_tuples = [(x / len(classes), 0.9, 1.0) for x in range(len(classes))] colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples)) colors = list( map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)), colors)) warning = False det_list = [2, 3, 7] for i in range(len(labels)): # for each bounding box, do: if labels[i] in det_list: mid_x = (boxes[i][0] + boxes[i][2]) / detection_size[0] / 2 mid_y = (boxes[i][1] + boxes[i][3]) / detection_size[1] / 2 re_width = (boxes[i][2] - boxes[i][0]) / detection_size[0] re_height = (boxes[i][3] - boxes[i][1]) / detection_size[1] # relative = np.sqrt(re_height**2+re_width**2) relative = round(((1 - re_width)**4), 2) # **4宽度变化反映在relative上的效果更加强烈 bbox, score, label = boxes[i], scores[i], classes[labels[i]] bbox_text = "%s %.2f %.2f" % (label, score, relative) color = colors[labels[i]] if 0.3 < mid_x < 0.7 and relative < 0.3: bbox_text = "%s" % ("WARNING") warning = True color = (255, 0, 255) text_size = draw.textsize(bbox_text, font) detection_size, original_size = np.array(detection_size), np.array( image.size) ratio = original_size / detection_size bbox = list((bbox.reshape(2, 2) * ratio).reshape(-1)) draw.rectangle(bbox, outline=color, width=3) text_origin = bbox[:2] - np.array([0, text_size[1]]) draw.rectangle( [tuple(text_origin), tuple(text_origin + text_size)], fill=color) # # draw bbox draw.text(tuple(text_origin), bbox_text, fill=(0, 0, 0), font=font) image.show() if show else None return image, warning
def class_colors(class_count): # make class 0 black, and the rest equally spaced fully saturated hues return [[0, 0, 0]] + [ colorsys.hsv_to_rgb(i / (class_count - 1.0), 1.0, 1.0) for i in range(class_count - 1) ]
def rgb(self): return colorsys.hsv_to_rgb(self.hue, self.saturation, self.value)
def test_FOV(M=10): env = rave.Environment() env.Load('../envs/pr2-test.env.xml') env.SetViewer('qtcoin') env.GetViewer().SendCommand( 'SetFiguresInCamera 1') # also shows the figures in the image time.sleep(1) robot = env.GetRobots()[0] convexify_workspace(env, robot) cam = robot.GetAttachedSensor('head_cam').GetSensor() type = rave.Sensor.Type.Camera cam_geom = cam.GetSensorGeometry(type) height, width, _ = cam_geom.imagedata.shape F = .01 # real focal length in meters max_range = 5. fov = FOV(robot, cam_geom.KK, height, width, F, max_range) cam_pose = tfx.pose([0, 0, 0.05], frame='wide_stereo_optical_frame') start = time.time() beams = fov.get_beams(cam_pose) print('beams time: {0}'.format(time.time() - start)) start = time.time() border = fov.get_border(beams) print('border time: {0}'.format(time.time() - start)) IPython.embed() return table = env.GetKinBody('table') base = table.GetLink('base') extents = base.Geometry.GetBoxExtents(base.GetGeometries()[0]) table_pos = tfx.pose(table.GetTransform()).position # assume table has orientation np.eye(3) x_min, x_max = table_pos.x - extents[0], table_pos.x + extents[0] y_min, y_max = table_pos.y - extents[1], table_pos.y + extents[1] z_min, z_max = table_pos.z + extents[2], table_pos.z + extents[2] + .2 particles = list() for i in xrange(M): x = random_within(x_min, x_max) y = random_within(y_min, y_max) z = random_within(z_min, z_max) particles.append(np.array([x, y, z])) signed_distances = list() for i in xrange(M): print(i) signed_distances.append( fov.signed_distance(particles[i], beams, border)) min_sd = min(signed_distances) sd_hue = np.array(signed_distances) + abs(min_sd) sd_hue = (1 / 3.0) * (sd_hue / max(sd_hue)) for p, h in zip(particles, sd_hue): rgb = colorsys.hsv_to_rgb(h, 1, 1) handles.append(utils.plot_point(env, p, color=rgb)) #fov.plot(beams) for tri in border: tri.plot(env) IPython.embed()
def main(): img = Image.open('/media/maxiaoyu/data/training_data/images/macaw2.jpg') img.load() #img.show() data = np.asarray(img) ds = data.shape print(data[1, 1, 1]) #zoom in """ zoom_scale = np.random.random((1,))[0] while zoom_scale > 0.3: zoom_scale = np.random.random((1,))[0] outimg_w = int(img.width * (1 + zoom_scale)) outimg_h = int(img.height * (1 + zoom_scale)) outimg = img.resize((outimg_w, outimg_h)) outimg.show() """ # hsv operation random_factor2 = random.uniform(0.7, 1.4) random_factor3 = random.uniform(-0.1, 1.0) random_factor4 = random.uniform(-0.1, 1.0) hsv = rgb_to_hsv(data) print(hsv.shape) """ for w in range(0, hsv.shape[0]): for h in range(0, hsv.shape[1]): s = hsv[w, h, 1] s = s * random_factor2 + random_factor3 hsv[w, h, 1] = s v = hsv[w, h, 2] v = v * random_factor2 + random_factor3 hsv[w, h, 2] = v """ #s hsv[:, :, 1] *= random_factor2 hsv[:, :, 1] += random_factor3 #v hsv[:, :, 2] *= random_factor2 hsv[:, :, 2] += random_factor3 #h hsv[:, :, 0] += random_factor4 rgbimg = hsv_to_rgb(hsv) outimg = Image.fromarray(rgbimg, mode="RGB") outimg.show('one') data2 = np.zeros(ds) for wi in range(0, ds[0]): for hi in range(0, ds[1]): r = data[wi, hi, 0] g = data[wi, hi, 1] b = data[wi, hi, 2] h, s, v = colorsys.rgb_to_hsv(r, g, b) h += random_factor4 s *= random_factor2 s += random_factor3 v *= random_factor2 v += random_factor3 rn, gn, bn = colorsys.hsv_to_rgb(h, s, v) #rn *= 255 #gn *= 255 #bn *= 255 data2[wi, hi, 0] = rn data2[wi, hi, 1] = gn data2[wi, hi, 2] = bn outimg2 = Image.fromarray(data2, mode="RGB") outimg2.show() #ci = scipy.misc.toimage(data2, cmin=0.0, cmax=1.0) #ci.show() print('show end') print('epoch : {0}, , running time : {1:.2f}m , left estimate : {2:.2f}m'.format(1, 0.345, 0.456))
def __init__(self, pos, color=(0, 125, 255), radius=15, is_head=False, is_self=False): pygame.sprite.Sprite.__init__(self) self.pos = tuple(pos) self.color = tuple(color) self.radius = radius self.is_head = is_head self.is_self = is_self global seg_images, head_images, base_head, base_seg, color_precision '''try: self.image = images[(self.color,radius)] except: self.image = pygame.Surface([self.radius*2,self.radius*2]) pygame.draw.ellipse(self.image,self.color,self.image.get_rect()) self.image.set_colorkey((0,0,0)) #print(f"type(color): {type(color)} is_head: {is_head}") images[(self.color,radius)] = self.image''' if self.is_head or True: self.image = pygame.Surface((self.radius * 2, self.radius * 2)) self.image.fill((255, 255, 0)) #self.image = pygame.transform.rotate(pygame.transform.scale(head_img,(self.radius*2,self.radius*2)),-head_rot) self.rect = self.image.get_rect() self.angle = 0 self.goal_angle = 0 self.rect.x = self.pos[0] - self.rect.width / 2 self.rect.y = self.pos[1] - self.rect.height / 2 #self.head_img = base_head.copy()#pygame.image.load("/home/USER/bin/python_io/head.png") if is_head: head_img = base_head.copy() #print("YAY!") #time.sleep(1) self.seg_img = base_seg.copy( ) #pygame.image.load("/home/USER/bin/python_io/segment.png") #seg_color = (240,10,128) self.seg_hue = round( colorsys.rgb_to_hsv(*self.color)[0], color_precision) self.head_hue = self.seg_hue if parsed_args['render_simple']: self.seg_hue = 268 / 360 self.head_hue = 268 / 360 if not self.is_self: self.seg_hue = 5 / 360 self.head_hue = 5 / 360 if not self.is_head: try: #print("found matching segment!") self.seg_img = seg_images[(self.seg_hue, self.radius)] except: for x in range(self.seg_img.get_width()): for y in range(self.seg_img.get_height()): #mult = (seg_img.get_at((x,y))[0]/255) #sc = seg_color #col = (round(sc[0]*mult),round(sc[1]*mult),round(sc[2]*mult)) rgb = self.seg_img.get_at((x, y))[:3] hsv = colorsys.rgb_to_hsv(*rgb) col = colorsys.hsv_to_rgb(self.seg_hue, hsv[1], hsv[2]) col = (int(col[0]), int(col[1]), int(col[2]), self.seg_img.get_at((x, y))[3]) self.seg_img.set_at((x, y), col) #seg_img.set_colorkey((0,0,0)) seg_images[(self.seg_hue, self.radius)] = self.seg_img if is_head: #print("heads are cool!") try: #self.head_hue = 0.5 self.head_img = head_images[(self.head_hue, self.radius)].copy() #self.image = self.head_img except: #print("original head!") #self.head_hue = 0.5 #print("1") #self.head_img = base_head.copy() temp_img = head_img.copy( ) #pygame.Surface((head_img.get_width(),head_img.get_height())) for x in range(head_img.get_width()): for y in range(head_img.get_height()): #mult = (seg_img.get_at((x,y))[0]/255) #sc = seg_color #col = (round(sc[0]*mult),round(sc[1]*mult),round(sc[2]*mult)) rgb = head_img.get_at((x, y))[:3] hsv = colorsys.rgb_to_hsv(*rgb) #print(f"head_hue:{self.head_hue}") col = colorsys.hsv_to_rgb(self.head_hue, hsv[1], hsv[2]) col = (int(col[0]), int(col[1]), int(col[2]), head_img.get_at((x, y))[3]) #self.head_img.set_at((x,y),col) temp_img.set_at((x, y), col) if rgb != (0, 0, 0) or col[:3] != (0, 0, 0): pass #print(f"Color was {rgb}, Color is: {col[:3]}, Pos ({x},{y})") #print("ONE!") head_images[( self.head_hue, self.radius)] = temp_img.copy() #self.head_img.copy() self.head_img = temp_img.copy() #self.image = temp_img.copy() #print("TWO!") if self.is_head: self.image = pygame.transform.rotate( pygame.transform.scale(self.head_img, (self.radius * 2, self.radius * 2)), -head_rot) else: self.image = pygame.transform.rotate( pygame.transform.scale(self.seg_img, (self.radius * 2, self.radius * 2)), -math.degrees(self.angle))
def setHue(self, hue): r, g, b = colorsys.hsv_to_rgb(hue, 1, 1) self.setRGB(r * 255, g * 255, b * 255)
Asm.WFI(0b10), # Palette magic, rainbow for rbrenderer *chain(*[[ Asm.MOV_R0(0x3000_0104), Asm.WRITE_IMM(i * 0x08040201), Asm.MOV_R0(0x3000_0108), Asm.WRITE_IMM(1 << (i % 32)), Asm.MOV_R0(0x3000_010c), Asm.WRITE_IMM(1 << (i % 32)), Asm.MOV_R0(0x3000_0110), Asm.WRITE_IMM(0b01010101_01010101_01010101_01010101 << (i % 2)), Asm.MOV_R0(0x3000_0114), Asm.WRITE_IMM(0b01010101_01010101_01010101_01010101 << (i % 2)), Asm.MOV_R0(0x3000_0008), Asm.WRITE_IMM(rgb_to_uint32(hsv_to_rgb(i / 255, 1.0, 0.5))), Asm.MOV_R0(0x3000_000C), Asm.WRITE_IMM(rgb_to_uint32(hsv_to_rgb(i / 255, 1.0, 1.0))), Asm.WFI(0b01), ] for i in range(255)]), # Patterns *chain(*[[ Asm.MOV_R0(0x3000_0100 + 4 * i), Asm.WRITE_IMM((1 << (i+1)) - 1), ] for i in range(10)]), Asm.JMP(0), ] class GFXDemoApplet(Applet, applet_name="gfxdemo"): help = "Graphics demo"
def ret_frame(cls, image): # Generate colors for drawing bounding boxes. hsv_tuples = [(x / 10, 1., 1.) for x in range(10)] colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples)) colors = list( map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)), colors)) np.random.seed(10101) # Fixed seed for consistent colors across runs. np.random.shuffle( colors) # Shuffle colors to decorrelate adjacent classes. np.random.seed(None) # Reset seed to default. start = timer() model_image_size = (608, 608) class_names = cls._get_class() new_image_size = (image.width - (image.width % 32), image.height - (image.height % 32)) boxed_image = letterbox_image(image, new_image_size) image_data = np.array(boxed_image, dtype='float32') image_data /= 255. image_data = np.expand_dims(image_data, 0) # Add batch dimension. image_shape = [image.size[1], image.size[0]] out_boxes, out_scores, out_classes = cls.compute_output( image_data, image_shape) Car_result_ALL = [] Pedestrian_result_ALL = [] all_result = [] font = ImageFont.truetype(font='../box_font/FiraMono-Medium.otf', size=np.floor(3e-2 * image.size[1] + 0.5).astype('int32')) thickness = (image.size[0] + image.size[1]) // 300 for i, c in reversed(list(enumerate(out_classes))): predicted_class = class_names[c] box = out_boxes[i] score = out_scores[i] label = '{}_{:.2f}_{}'.format( predicted_class, score, str(cls.IDvalue)) #put the ID for each obj draw = ImageDraw.Draw(image) label_size = draw.textsize(label, font) top, left, bottom, right = box top = max(0, np.floor(top + 0.5).astype('int32')) left = max(0, np.floor(left + 0.5).astype('int32')) bottom = min(image.size[1], np.floor(bottom + 0.5).astype('int32')) right = min(image.size[0], np.floor(right + 0.5).astype('int32')) #JSON 形式の時はint32()未対応のため -> int()に変換する top = int(top) left = int(left) bottom = int(bottom) right = int(right) if top - label_size[1] >= 0: text_origin = np.array([left, top - label_size[1]]) else: text_origin = np.array([left, top + 1]) #1 予測結果より次のFrameの物体位置を予測 #nxt_result_txt = ' {},{},{},{},{}'.format(left, top, right, bottom, c) #2 検出したbox_sizeを計算する 設定した閾値1024pix**2 sq_bdbox = (bottom - top) * (right - left) if sq_bdbox >= 1024: #矩形サイズの閾値 if predicted_class == 'Car' or predicted_class == 'Pedestrian': # Car or Pedes # My kingdom for a good redistributable image drawing library. for i in range(thickness): draw.rectangle( [left + i, top + i, right - i, bottom - i], outline=colors[c]) draw.rectangle( [tuple(text_origin), tuple(text_origin + label_size)], fill=colors[c]) draw.text(text_origin, label, fill=(0, 0, 0), font=font) del draw end = timer() print("1フレームの処理時間 = ", end - start) return image
#!/usr/bin/env python import colorsys import time import blinkt spacing = 360.0 / 16.0 hue = 0 blinkt.set_clear_on_exit() blinkt.set_brightness(0.035) while True: hue = int(time.time() * 100) % 360 for x in range(blinkt.NUM_PIXELS): offset = x * spacing h = ((hue + offset) % 360) / 360.0 r, g, b = [int(c*255) for c in colorsys.hsv_to_rgb(h, 1.0, 1.0)] blinkt.set_pixel(x, r, g, b) blinkt.show() time.sleep(0.001)
def _get_random_xy_color(self): random_color = colorsys.hsv_to_rgb(random.random(), 1, 1) random_color = tuple([255 * x for x in random_color]) return self.converter.rgbToCIE1931(*random_color)
anchors = [float(x) for x in anchors.split(',')] anchors = np.array(anchors).reshape(-1, 2) yolo_model_keras = load_model(model_path) # Verify model, anchors, and classes are compatible num_of_classes = len(class_tags) num_of_anchors = len(anchors) model_output_channels = yolo_model_keras.layers[-1].output_shape[-1] model_image_size = yolo_model_keras.layers[0].input_shape[1:3] is_fixed_size = model_image_size != (None, None) # Generate colors for drawing bounding boxes. hsv_tuples = [(x / len(class_tags), 1., 1.) for x in range(len(class_tags))] colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples)) colors = list( map( lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)), colors)) random.seed(10101) # Fixed seed for consistent colors across runs. random.shuffle(colors) # Shuffle colors to decorrelate adjacent classes. random.seed(None) # Reset seed to default. # Generate output tensor targets for filtered bounding boxes. yolo_outputs = yolo_head(yolo_model_keras.output, anchors, len(class_tags)) input_image_shape = K.placeholder(shape=(2, )) boxes, scores, classes = yolo_eval( yolo_outputs, input_image_shape, score_threshold=score_threshold,
def addObject(self, color=None): label = self.labelmgr.request() if color is None: color = colorsys.hsv_to_rgb(numpy.random.random(), 1.0, 1.0) self.setColor(label, color) return label
def set_pixel_hsv(self, x, y, h, s=1.0, v=1.0): r, g, b = [int(n * 255) for n in colorsys.hsv_to_rgb(h, s, v)] self.set_pixel(x, y, r, g, b)
def _set_hue(self, hue): self.hueValue = min(0.999, hue) self.hueHandle.top = (1.0-hue) * 128.0 - self.hueHandle.height / 2 self.fieldBG.color = colorsys.hsv_to_rgb(self.hueValue, 1, 1)
def visualize_pts_line(pts_array, line_index_list, method=2, seed=0, alpha=0.5, vis_threshold=0.3, pts_size=20, line_size=10, line_color_index=0, fig=None, ax=None, save_path=None, vis=False, warning=True, debug=True, closefig=True): ''' given a list of index, and a point array, to plot a set of points with line on it inputs: pts_array: 2(3) x num_pts line_index_list: a list of index method: 1: all points are connected, if some points are missing in the middle, just ignore that point and connect the two nearby points 2: if some points are missing in the middle of a line, the line is decomposed to sub-lines vis_threshold: confidence to draw the points ''' if debug: assert is2dptsarray(pts_array) or is2dptsarray_occlusion( pts_array) or is2dptsarray_confidence( pts_array), 'input points are not correct' assert islist(line_index_list), 'the list of index is not correct' assert method in [1, 2], 'the plot method is not correct' num_pts = pts_array.shape[1] # expand the pts_array to 3 rows if the confidence row is not provided if pts_array.shape[0] == 2: pts_array = np.vstack((pts_array, np.ones((1, num_pts)))) fig, ax = get_fig_ax_helper(fig=fig, ax=ax) np.random.seed(seed) color_option = 'hsv' if color_option == 'rgb': color_set_random = np.random.rand(3, num_pts) elif color_option == 'hsv': h_random = np.random.rand(num_pts, ) color_set_random = np.zeros((3, num_pts), dtype='float32') for pts_index in range(num_pts): color_set_random[:, pts_index] = colorsys.hsv_to_rgb( h_random[pts_index], 1, 1) line_color = color_set[line_color_index] pts_line = pts_array[:, line_index_list] if method == 1: valid_pts_list = np.where(pts_line[2, :] > vis_threshold)[0].tolist() pts_line_tmp = pts_line[:, valid_pts_list] ax.plot(pts_line_tmp[0, :], pts_line_tmp[1, :], lw=line_size, color=line_color, alpha=alpha) # plot all lines # plot all points for pts_index in valid_pts_list: pts_index_original = line_index_list[pts_index] # ax.plot(pts_array[0, pts_index_original], pts_array[1, pts_index_original], 'o', color=color_set_big[pts_index_original % len(color_set_big)], alpha=alpha) ax.plot(pts_array[0, pts_index_original], pts_array[1, pts_index_original], marker='o', ms=pts_size, lw=line_size, color=color_set_random[:, pts_index], alpha=alpha) else: not_valid_pts_list = np.where( pts_line[2, :] < vis_threshold)[0].tolist() if len(not_valid_pts_list) == 0: # all valid ax.plot(pts_line[0, :], pts_line[1, :], lw=line_size, color=line_color, alpha=alpha) # plot points for pts_index in line_index_list: # ax.plot(pts_array[0, pts_index], pts_array[1, pts_index], 'o', color=color_set_big[pts_index % len(color_set_big)], alpha=alpha) ax.plot(pts_array[0, pts_index], pts_array[1, pts_index], marker='o', ms=pts_size, lw=line_size, color=color_set_random[:, pts_index], alpha=alpha) else: prev_index = 0 for not_valid_index in not_valid_pts_list: plot_list = range(prev_index, not_valid_index) pts_line_tmp = pts_line[:, plot_list] ax.plot(pts_line_tmp[0, :], pts_line_tmp[1, :], lw=line_size, color=line_color, alpha=alpha) # plot points for pts_index in plot_list: pts_index_original = line_index_list[pts_index] ax.plot(pts_array[0, pts_index_original], pts_array[1, pts_index_original], marker='o', ms=pts_size, lw=line_size, color=color_set_random[:, pts_index_original], alpha=alpha) # ax.plot(pts_array[0, pts_index_original], pts_array[1, pts_index_original], 'o', color=color_set_big[pts_index_original % len(color_set_big)], alpha=alpha) prev_index = not_valid_index + 1 pts_line_tmp = pts_line[:, prev_index:] ax.plot(pts_line_tmp[0, :], pts_line_tmp[1, :], lw=line_size, color=line_color, alpha=alpha) # plot last line # plot last points for pts_index in range(prev_index, pts_line.shape[1]): pts_index_original = line_index_list[pts_index] # ax.plot(pts_array[0, pts_index_original], pts_array[1, pts_index_original], 'o', color=color_set_big[pts_index_original % len(color_set_big)], alpha=alpha) ax.plot(pts_array[0, pts_index_original], pts_array[1, pts_index_original], marker='o', ms=pts_size, lw=line_size, color=color_set_random[:, pts_index_original], alpha=alpha) return save_vis_close_helper(fig=fig, ax=ax, vis=vis, save_path=save_path, warning=warning, debug=debug, closefig=closefig)
0.73, 0.80, 0.87, 0.45, 0.52, 0.60, 0.67, 0.74, 0.81, 0.88, 0.95, ] hat = SenseHat() def scale(v): return int(v * 255) while True: # Rotate the hues hues = [(h + 0.01) % 1.0 for h in hues] # Convert the hues to RGB values pixels = [hsv_to_rgb(h, 1.0, 1.0) for h in hues] # hsv_to_rgb returns 0..1 floats; convert to ints in the range 0..255 pixels = [(scale(r), scale(g), scale(b)) for r, g, b in pixels] # Update the display hat.set_pixels(pixels) sleep(0.04)
def _hsv_to_rgb(tup): return tuple(int(i * 255) for i in colorsys.hsv_to_rgb(*tup))
def set_hsv_coord(self, *, h=None, s=None, v=None, min_h=0, max_h=1, min_s=0, max_s=1, min_v=0, max_v=1) -> Color: h2, s2, v2 = self.hsv return self.c(*colorsys.hsv_to_rgb(max(min_h, min(max_h, h or h2)), max(min_s, min(max_s, s or s2)), max(min_v, min(max_v, v or v2))))
from PIL import Image import random from vis import Vis, Word import vis import pandas as pd from string import ascii_letters import colorsys def main(): pass if __name__ == '__main__': special_color = tuple( [int(item * 255) for item in colorsys.hsv_to_rgb(0.05, 0.7, 0.85)]) # background_color = (247, 237, 226) # background_color_bgr = (226, 237, 247) background_color_bgr = background_color = (20, 20, 20) font_color = (240, 240, 240) # special_color = (88, 130, 135) v = Vis(special_color=special_color) w = Word() c = Canvas('framework_3') c.set_bg_color(background_color_bgr) c.set_font_color(font_color) c.set_special_color(special_color) c.add_layer(Layer(img=v.get(vis.dist_vis), alpha=1, title='成绩变化'))
def toRGB(self): return colorsys.hsv_to_rgb(self.h, self.s, self.b)
def hue_rotate(self, angle) -> Color: h, s, v = self.hsv return self.c(*colorsys.hsv_to_rgb((h + angle) % 1, s, v))
def LoadModel(self, detection_speed="normal"): if (self.__modelType == "yolov3"): if (detection_speed == "normal"): self.__yolo_model_image_size = (416, 416) elif (detection_speed == "fast"): self.__yolo_model_image_size = (320, 320) elif (detection_speed == "faster"): self.__yolo_model_image_size = (208, 208) elif (detection_speed == "fastest"): self.__yolo_model_image_size = (128, 128) elif (detection_speed == "flash"): self.__yolo_model_image_size = (96, 96) elif (self.__modelType == "tinyyolov3"): if (detection_speed == "normal"): self.__yolo_model_image_size = (832, 832) elif (detection_speed == "fast"): self.__yolo_model_image_size = (576, 576) elif (detection_speed == "faster"): self.__yolo_model_image_size = (416, 416) elif (detection_speed == "fastest"): self.__yolo_model_image_size = (320, 320) elif (detection_speed == "flash"): self.__yolo_model_image_size = (272, 272) if (self.__modelLoaded == False): if (self.__modelType == ""): raise ValueError( "You must set a valid model type before loading the model." ) elif (self.__modelType == "yolov3"): model = yolo_main(Input(shape=(None, None, 3)), len(self.__yolo_anchors) // 3, len(self.numbers_to_names)) model.load_weights(self.modelPath) hsv_tuples = [(x / len(self.numbers_to_names), 1., 1.) for x in range(len(self.numbers_to_names))] self.colors = list( map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples)) self.colors = list( map( lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)), self.colors)) np.random.seed(10101) np.random.shuffle(self.colors) np.random.seed(None) self.__yolo_input_image_shape = K.placeholder(shape=(2, )) self.__yolo_boxes, self.__yolo_scores, self.__yolo_classes = yolo_eval( model.output, self.__yolo_anchors, len(self.numbers_to_names), self.__yolo_input_image_shape, score_threshold=self.__yolo_score, iou_threshold=self.__yolo_iou) self.__model_collection.append(model) self.__modelLoaded = True elif (self.__modelType == "tinyyolov3"): model = tiny_yolo_main(Input(shape=(None, None, 3)), len(self.__tiny_yolo_anchors) // 2, len(self.numbers_to_names)) model.load_weights(self.modelPath) hsv_tuples = [(x / len(self.numbers_to_names), 1., 1.) for x in range(len(self.numbers_to_names))] self.colors = list( map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples)) self.colors = list( map( lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)), self.colors)) np.random.seed(10101) np.random.shuffle(self.colors) np.random.seed(None) self.__yolo_input_image_shape = K.placeholder(shape=(2, )) self.__yolo_boxes, self.__yolo_scores, self.__yolo_classes = yolo_eval( model.output, self.__tiny_yolo_anchors, len(self.numbers_to_names), self.__yolo_input_image_shape, score_threshold=self.__yolo_score, iou_threshold=self.__yolo_iou) self.__model_collection.append(model) self.__modelLoaded = True
def highlight_rgb(r, g, b, amount=0.1): h, s, v = colorsys.rgb_to_hsv(r, g, b) return colorsys.hsv_to_rgb(h, s, (v + amount) % 1)