def testEquals(self): g1 = gradient.Gradient() g2 = gradient.Gradient() self.failUnless(g1 == g2) # calls __eq__ self.assertEqual(g1, g2) # calls __ne__ g1.segments[0].left_color[0] = 0.7 self.assertNotEqual(g1, g2)
def testLoadCompressed(self): g = gradient.Gradient() s = StringIO.StringIO(wood) g.load(s) s2 = StringIO.StringIO() g.save(s2, True) s2.seek(0, 0) g_from_comp = gradient.Gradient() g_from_comp.load(s2) self.assertEqual(g, g_from_comp)
def testGreyGradient(self): g = gradient.Gradient() # linear, central midpoint g.segments[0].mid = 0.5 self.checkGreyGradient(g, 0.5, lambda x, mid: x) # linear, off-center midpoint def predict_025_linear(x, dummy): if x <= 0.25: fx = 0.5 * x / 0.25 else: fx = 0.5 + 0.5 * (x - 0.25) / 0.75 return fx g.segments[0].mid = 0.25 self.checkGreyGradient(g, 0.25, predict_025_linear) # curved, central midpoint # (curved = linear if midpoint = 0.5) g.segments[0].bmode = Blend.CURVED g.segments[0].mid = 0.5 self.checkGreyGradient(g, 0.5, lambda x, mid: x) # curved, non-central midpoint, sharper at the start def predict_025_curved(x, dummy): if x == 0.0: fx = 0.0 else: fx = math.pow(x, math.log(0.5) / math.log(0.25)) return fx g.segments[0].mid = 0.25 self.checkGreyGradient(g, 0.25, predict_025_curved)
def __init__(self, path, visualize=False, writing_method='cv', division="normal", column=5, row=5): self.logger = logging.getLogger("Borg.Brain.Vision.hog.Main_pro") self.visualize = visualize self.path = os.path.join(path, '') self.IDs = 0 self.divider = divider.Divider() self.divider2 = divider.Divider() self.gradient = gradient.Gradient() self.hog = hog.HoG(writing_method) self.writing_method = writing_method self.IDnumbers = 0 self.divisionOption = division self.column = column self.row = row self.dividerTime = [] self.gradientTime = [] self.histogramTime = [] self.mainTime = 0 self.cpu_count = multiprocessing.cpu_count()
def testAlphaChannel(self): g = gradient.Gradient() g.segments[0].left_color[3] = 0.5 self.assertWellFormedGradient(g) for i in xrange(256): x = i * 1.0 / 256.0 self.assertEqual(g.get_color_at(x), [x, x, x, 0.5 + x / 2.0])
def testLoadSimple(self): g = gradient.Gradient() s = StringIO.StringIO(wood) g.load(s) self.assertEqual(g.name, "Wood 2") self.assertEqual(len(g.segments), 9) # check round trip s2 = StringIO.StringIO() g.save(s2) self.assertEqual(wood, s2.getvalue()) g2 = gradient.Gradient() s2.seek(0, 0) g2.load(s2) self.assertEqual(g, g2)
def __init__(self,parent=None): fctutils.T.__init__(self,parent) self.name = "default" self.gradient = gradient.Gradient() self.solids = [(0,0,0,255)] self.direct = False self.rgb = [0,0,0] self.read_gradient = False
def create_rgb_gradient(self): # make a simple gradient which goes from R -> G -> B g = gradient.Gradient() g.segments = [ gradient.Segment(0.0, self.red, 0.333, self.red), gradient.Segment(0.333, self.green, 0.667, self.green), gradient.Segment(0.667, self.blue, 1.0, self.blue) ] return g
def testSaveMinimal(self): g = gradient.Gradient() s = StringIO.StringIO() g.save(s) self.assertEqual( s.getvalue(), '''GIMP Gradient 1 0.000000 0.500000 1.000000 0.000000 0.000000 0.000000 1.000000 1.000000 1.000000 1.000000 1.000000 0 0 ''')
def testFromColormap3(self): # create a short, compressible one colorlist = [(0.0, 0, 0, 0, 255), (0.5, 127, 127, 127, 255), (1.0, 255, 255, 255, 255)] g = gradient.Gradient() g.load_list(colorlist) self.assertWellFormedGradient(g) self.assertEqual(len(g.segments), 1)
def get_gradient(self, filename, formname): g = gradient.Gradient() if formname == None: g.load(open(self.find_file(filename, 3))) # FIXME else: compiled_gradient = self.get_formula(filename, formname) g.load_ugr(compiled_gradient) return g
def loop(self): t = self.uoap_index * 2 * pi jitter = sin(t) / 4 p = [(0.0, self.colors[0]), (0.45 + jitter, self.colors[1]), (0.65 + jitter, self.colors[1]), (1.0, self.colors[0])] g = gradient.Gradient(self.num_leds, p) g.render(self.led_art, 1 | 2 | 4) p = [(0.0, self.colors[0]), (0.65 - jitter, self.colors[1]), (0.45 - jitter, self.colors[1]), (1.0, self.colors[0])] g = gradient.Gradient(self.num_leds, p) g.render(self.led_art, 8 | 16 | 32) self.led_art.show() self.uoap_index += self.uoap_increment if self.uoap_index > 1.0: self.uoap_index = 0.0
def testSetMiddle(self): g = gradient.Gradient() # should be able to move self.assertEqual(g.set_middle(0, 0.4), 0.4) self.assertEqual(g.set_middle(0, 0.6), 0.6) # but no further than endpoints self.assertEqual(g.set_middle(0, 0.0), 0.0 + gradient.Segment.EPSILON) self.assertEqual(g.set_middle(0, 1.0), 1.0 - gradient.Segment.EPSILON)
def test_gradient(gradient_tag, input_svg, data): input_root = etree.fromstring(input_svg, base.parser) input_gradient_tag = input_root.find(".//*[@id='acyl-gradient']") gradient_inst = gradient.Gradient(tag=gradient_tag) input_gradient_tag.getparent().replace(input_gradient_tag, gradient_inst.build(data)) changed_svg_bytes = etree.tostring(input_root) reference_svg_bytes = etree.tostring(etree.fromstring(input_svg, base.parser)) assert changed_svg_bytes == reference_svg_bytes
def testFromColormap(self): # check that creating a gradient from a colormap produces the same # output colorlist = [(0.0, 255, 255, 255, 255), (1.0, 0, 0, 0, 255)] g = gradient.Gradient() g.load_list(colorlist) self.assertEqual(len(g.segments), 1) self.assertEqual(g.segments[0].left_color, self.white) self.assertEqual(g.segments[0].right_color, self.black) self.checkColorMapAndGradientEquivalent(colorlist)
def split(self, file): text = open(file).read() t = self.translateGradient(text) for grad in t.children: t = translate.GradientFunc(grad) g = gradient.Gradient() g.load_ugr(t) out_name = g.name + ".ggr" f = open("gradients/" + out_name, "w") print >> f, g.serialize() f.close()
def testLoadCS(self): g = gradient.Gradient() f = open("../testdata/test.cs") g.load_cs(f) self.assertEqual(8, len(g.segments)) self.assertEqual([0x1d / 255.0, 0x10 / 255.0, 0x10 / 255.0, 1.0], g.segments[0].left_color) f.seek(0) g.load(f)
def testColors2(self): colors = parfile.colorRange( "0000HG5JA9L6VNRlCeJC0JJRJCnJ6z`UzokzuuuzzzfbjqaxkTreHn_6i`9oaAtbCzbCz_NzVUzR`yNhwHnvCss9yrozzrpzvfzyXzzLzz6yzGwzOvzUsz`ryepxkowpntnqrlspkwniykhzifzhezdiq`laXpJUr0GbsLawO`yR_zUYzYXz`VzbUzeUzkVzqXzwYzz_zz`zzazsiw_paVrbTtbQwbLybHzbEzbOqhVdlaQpYXiUaaRhUNlLJqAz5bz2fz2iz2kz0nz0pw0rt0ts6ssCsrGrrLrrQrqTqqXqq_qlYjhXbbVXYUOTTGNR5HQ0LTANUNOXXRYeT`nUavVbzU_zTXzRUzRRzQOzOLzNHyNEyXHweLvlOstRrzUpzVox_jnaebdaQfXAiR0kN0nH5pCAr6Gs2Lk5Qb6TV9XLA`9Cb0CVCAOOAE_A5hACiOJiYQifVjp`jxejzohqxebzbNza0o_jJXzYiyishszOqvRpnUneXlX_jNaiAdh0feE`dTVadQ`oJYyCXz5TnGalRjk`rjiziqziytjYhk0jiCkfQle`niVnkQnnJnpCnr5nt0fo6_iGRbOHXV9RaTHjf9rs0yvftwzpsznpzklziizfezdazarzwozxlzxizxfzybzy`zyYzyVzzTzzQzzNzzJzzHzzGzzEzzCztAzl9ze6zYzzQzzzzzyzzqzzhzz_zzkzzvzzzzzijzelzazzzzzzzzzzzzzzzzzzzzzvzxozsizpazk0zR0zO0zL" ) check_grad = gradient.Gradient() check_grad.load_map_file(StringIO.StringIO(map), -1) for (thecolor, expcolor) in zip(colors[1:], check_grad.segments): self.assertEqual(thecolor[0], int(255 * expcolor.left_color[0])) self.assertEqual(thecolor[1], int(255 * expcolor.left_color[1])) self.assertEqual(thecolor[2], int(255 * expcolor.left_color[2]))
def testAddSegment(self): # add some segments, ensure invariants hold and correct # outcome occurs. g = gradient.Gradient() # add a segment at left-hand end g.add(0) self.assertWellFormedGradient(g) self.assertEqual(len(g.segments), 2) left = g.segments[0] right = g.segments[1] self.assertEqual(left.right_color, right.left_color) self.assertEqual(left.right_color, [0.5, 0.5, 0.5, 1.0]) self.assertEqual(right.right_color, [1.0, 1.0, 1.0, 1.0]) self.assertEqual(left.mid, 0.25) self.assertEqual(left.right, 0.5) self.assertEqual(right.mid, 0.75) self.assertEqual(right.right, 1.0) # should have no effect on resulting pattern self.checkGreyGradient(g, 0.5, lambda x, mid: x) # add another one g.add(0) self.assertWellFormedGradient(g) self.assertEqual(len(g.segments), 3) left = g.segments[0] right = g.segments[1] self.assertEqual(left.right_color, right.left_color) self.assertEqual(left.right_color, [0.25, 0.25, 0.25, 1.0]) self.assertEqual(left.mid, 0.125) self.assertEqual(left.right, 0.25) self.assertEqual(right.mid, 0.375) self.assertEqual(right.right, 0.5) # still no effect self.checkGreyGradient(g, 0.5, lambda x, mid: x) # one more at the other end g.add(len(g.segments) - 1) self.assertWellFormedGradient(g) self.assertEqual(len(g.segments), 4) left = g.segments[2] right = g.segments[3] self.assertEqual(left.right_color, right.left_color) self.assertEqual(left.right_color, [0.75, 0.75, 0.75, 1.0]) self.assertEqual(left.mid, 0.625) self.assertEqual(left.right, 0.75) self.assertEqual(right.mid, 0.875) self.assertEqual(right.right, 1.0) # still no effect self.checkGreyGradient(g, 0.5, lambda x, mid: x)
def loop(self): t = self.uoap_index * 2 * pi jitter = sin(t) / 4 p = [(0.0, self.colors[0]), (0.45 + jitter, self.colors[1]), (0.65 + jitter, self.colors[1]), (1.0, self.colors[0])] g = gradient.Gradient(config.NUM_LEDS, p) g.render(self.led_art, 2) self.led_art.show() self.uoap_index += self.uoap_increment if self.uoap_index > 1.0: self.uoap_index = 0.0
def __init__(self, host, port, path, opath, discountfactor=0.99, method="cv"): self.logger = logging.getLogger("Borg.Brain.Vision.hog.Decider") super(Decider, self).__init__(host, port) self.path = path self.opath = opath self.writing_method = method self.divider = divider.Divider() self.gradient = gradient.Gradient() self.hog = hog.HoG("hist") self.column = 5 self.row = 5 self.goal_location = None self.current_location = None self.currentFeature = None try: self.kcenters = self.load_center() self.logger.info("Center file loaded successfully") except: self.logger.error("Cannot Load Center File") self.values = None self.qvalues = None self.discountValue = discountfactor try: self.tp_matrix = self.load_tp_matrix() self.logger.info("Loading TP matrix... Ok") except: self.logger.error("Cannot Open TP_matrix file") self.reward = 0 #fornow self.stopping_criterion = 0.0001 self.goal = False self.action = False self.name = "" self.temperature = 100 self.numberofactions = 7 self.finish = False
def testFromColormap2(self): # create a longer one colorlist = [(0.0, 255, 0, 0, 255), (0.5, 0, 255, 0, 255), (1.0, 0, 0, 255, 255)] g = gradient.Gradient() g.load_list(colorlist) self.assertWellFormedGradient(g) self.assertEqual(len(g.segments), 2) self.assertEqual(g.segments[0].left_color, self.red) self.assertEqual(g.segments[0].right_color, self.green) self.assertEqual(g.segments[1].left, 0.5) self.assertEqual(g.segments[1].left_color, self.green) self.assertEqual(g.segments[1].right_color, self.blue) self.checkColorMapAndGradientEquivalent(colorlist)
def loop(self): hues = self.create_analogous_palette(self.hue) palettes = self.make_palettes(hues) for i, pal in enumerate(palettes): strip = 1 << i try: g = gradient.Gradient(self.num_leds, pal) g.render(self.led_art, 1 << i) except ValueError as err: pass self.led_art.show() self.hue += self.hue_increment sleep(5)
def testSetRight(self): g = gradient.Gradient() g.add(0) # shouldn't be able to move rightmost segment self.assertEqual(g.set_right(1, -1.0), 1.0) self.assertEqual(g.set_right(1, 0.2), 1.0) # should be able to move other one self.assertEqual(g.set_right(0, 0.4), 0.4) self.assertEqual(g.set_right(0, 0.6), 0.6) # but no further than midpoints self.assertEqual(g.set_right(0, 0.2), 0.25 + gradient.Segment.EPSILON) self.assertEqual(g.set_right(0, 0.8), 0.75 - gradient.Segment.EPSILON)
def testFromUgr(self): pt = fractparser.parser.parse('''blatte10 { gradient: title="blatte10" smooth=no index=0 color=3085069 index=25 color=3216141 index=56 color=10761236 index=83 color=1408165 index=92 color=4050153 index=110 color=18018 index=134 color=0 index=213 color=5183243 index=284 color=11494485 index=358 color=0 index=384 color=144 opacity: smooth=no index=0 opacity=255 } ''') t = translate.GradientFunc(pt.children[0], "f") g = gradient.Gradient() g.load_ugr(t) self.assertWellFormedGradient(g) self.assertEqual(len(g.segments), 12)
def loop(self): try: g = gradient.Gradient(config.NUM_LEDS, self.palette) g.set_scale(self.scale) g.set_offset(self.offset) g.render(self.led_art, 2) self.led_art.show() except ValueError as err: print(err) pass self.t += .08 self.scale = 2.0 + (sin(self.t) / 1.0) self.offset = .5 + (cos(self.t) / 4.0) # print("%.3f %.3f" % (self.offset, self.scale)) sleep(.005)
def draw(xmin, xsize, ymin, ysize, window): g = gradient.Gradient([ (0, 0, 0), (0, 255, 0), (255, 0, 0), (0, 0, 255), (255, 255, 0), (255, 255, 255) ]) for y in range(2*size): ypos = ymin + ((y / (3.0*size)) * ysize) for x in range(3*size): xpos = xmin + ((x / (2.0*size)) * xsize) perc = continuousTime((xpos, ypos), iterations=iterations, threshold=100) / float(iterations) color = g.getColor(perc) pygame.draw.line(window, color, (x, y), (x, y)) pygame.display.update()
def loop(self): try: g = gradient.Gradient(self.num_leds, self.points) g.render(self.led_art, 0xFF) self.led_art.show() except ValueError as err: pass # Move all the points down a smidge for i in range(len(self.palette)): self.palette[i] = [ self.palette[i][0] + self.render_increment, self.palette[i][1] ] # Has my closest point gone over 0.0? Time to insert a new point! if self.palette[0][0] > 0.0: self.palette.insert(0, [ self.palette[0][0] - self.point_distance, self.source[self.source_index] ]) self.source_index = (self.source_index + 1) % len(self.source) if not self.source: self.source = list(palette.create_random_palette()) # clean up the point(s) that went out the other end try: while self.palette[-2][0] > 1.0: self.palette.pop() except IndexError: pass if self.num_new_points == 10: self.source = list(palette.create_random_palette()) self.source_index = 0 self.num_new_points = 0 self.num_new_points += 1 sleep(.03)
def testGradientCmap(self): g = gradient.Gradient() self.checkCGradientAndPyGradientEquivalent(g) g.segments[0].mid = 0.2 self.checkCGradientAndPyGradientEquivalent(g) g.segments[0].bmode = gradient.Blend.CURVED self.checkCGradientAndPyGradientEquivalent(g) g.segments[0].bmode = gradient.Blend.SINE self.checkCGradientAndPyGradientEquivalent(g) g.segments[0].bmode = gradient.Blend.SPHERE_INCREASING self.checkCGradientAndPyGradientEquivalent(g) g.segments[0].bmode = gradient.Blend.SPHERE_DECREASING self.checkCGradientAndPyGradientEquivalent(g) g = self.create_rgb_gradient() self.checkCGradientAndPyGradientEquivalent(g)
def testRemoveSmooth(self): # test removal of segments g = gradient.Gradient() g.segments = self.three_segments() self.assertWellFormedGradient(g) self.checkGreyGradient(g, 0.5, lambda x, mid: x) # remove middle one g.remove(1, True) self.assertEqual(len(g.segments), 2) self.assertWellFormedGradient(g) self.checkGreyGradient(g, 0.5, lambda x, mid: x) self.assertEqual(g.segments[0].right, 0.5) # recreate and remove left one g.segments = self.three_segments() self.assertWellFormedGradient(g) self.checkGreyGradient(g, 0.5, lambda x, mid: x) g.remove(0, True) self.assertEqual(len(g.segments), 2) self.assertWellFormedGradient(g) self.checkGreyGradient(g, 0.5, lambda x, mid: x) self.assertEqual(g.segments[0].right, 2.0 / 3.0) # recreate and remove right one g.segments = self.three_segments() self.assertWellFormedGradient(g) self.checkGreyGradient(g, 0.5, lambda x, mid: x) g.remove(2, True) self.assertEqual(len(g.segments), 2) self.assertWellFormedGradient(g) self.checkGreyGradient(g, 0.5, lambda x, mid: x) self.assertEqual(g.segments[1].left, 1.0 / 3.0)