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)
