In [1]:

    

import unittest
import numpy as np


    

In [78]:

    

from sklearn.externals import joblib
clf = joblib.load('../filename.pkl')


    

In [242]:

    

test_values = [[45,45,0]]
clf.predict_proba(test_values)


    

    
Out[242]:





array([[ 0.3,  0. ,  0.2,  0.5]])

In [236]:

    

def getPixelValue(val):
    # takes a value between 0-33.3333
    # Returns an array of RGB colors ranging between White -> Blue
    # Values Close to 0 are mapped to White 
    # Values clost to 33.333 are mapped to Blue
    # It should be a gradient between white to blue for 0 -> 33.333
    # return black if val <= 0
    
    
    if val <= 0:
        return [0,0,0]

    if val > .33333:
        return [0,0,255]
    
    color = int(255 - np.round(765 * val ))
    return [color,color,255]
    
    
def getPixelsValue(val):
    # takes a value between 0-1
    # returns an array that represents rgb values for three pixels
    # The pixels 'Fill up' from 0 to 1
    # values between [0:1/3) will fill up the first pixel
    # values between [1/3:2/3) will have the first pixel 'full' and filling the second
    # values between [2/3:1] will have the first two pixels 'full' and the third one filling
    # pixels are black until they start filling
    
    delimeter = 1.0 / 3.0
    
    if(int(val / delimeter) <= 0):
        return [getPixelValue(val),[0,0,0],[0,0,0]]
    
    if(int(val / delimeter) == 1):
        return [[0,0,255],getPixelValue(val % delimeter),[0,0,0]]
    
    if(int(val / delimeter) == 2):
        return [[0,0,255],[0,0,255],getPixelValue(val % delimeter)]
    
    if(int(val / delimeter) >= 3):
        return [[0,0,255],[0,0,255],[0,0,255]]


    

In [237]:

    

val1 = 1.0 / 3.0
val2 = .1
val3 = .5  # 1 + 1/6
val4 = -1  

delimeter = 1.0 / 3.0

print val1 / delimeter
print val1 % delimeter




print val2 / delimeter
print val2 % delimeter

print int(val3 / delimeter)
print val3 % delimeter

print int(val4 / delimeter)
print val4 % delimeter


    

    




1.0
0.0
0.3
0.1
1
0.166666666667
-3
0.333333333333

In [238]:

    

class GetPixelValueTest(unittest.TestCase):  

    def test_value_0(self):  
        
        self.assertEqual([0,0,0], getPixelValue(0))  
        
    def test_value_00012(self):  
        
        self.assertEqual([255,255,255], getPixelValue(0.00012))  

    def test_value_33_33(self):  
        
        self.assertEqual([0,0,255], getPixelValue(.33333)) 
        
    def test_value_33_34(self):  
        
        self.assertEqual([0,0,255], getPixelValue(.3334)) 
        
    def test_value_33(self):  
        
        self.assertEqual([3,3,255], getPixelValue(.33)) 
        
    def test_value_15(self):  
        
        self.assertEqual([140,140,255], getPixelValue(.15)) 
        
    def test_value_11(self):  
        
        self.assertEqual([171,171,255], getPixelValue(.11))  
        
    def test_value_negative(self):  
        
        self.assertEqual([0,0,0], getPixelValue(-1))


    

In [239]:

    

suite = unittest.TestLoader().loadTestsFromTestCase(GetPixelValueTest)
unittest.TextTestRunner(verbosity=2).run(suite)


    

    




test_value_0 (__main__.GetPixelValueTest) ... ok
test_value_00012 (__main__.GetPixelValueTest) ... ok
test_value_11 (__main__.GetPixelValueTest) ... ok
test_value_15 (__main__.GetPixelValueTest) ... ok
test_value_33 (__main__.GetPixelValueTest) ... ok
test_value_33_33 (__main__.GetPixelValueTest) ... ok
test_value_33_34 (__main__.GetPixelValueTest) ... ok
test_value_negative (__main__.GetPixelValueTest) ... ok

----------------------------------------------------------------------
Ran 8 tests in 0.009s

OK






    
Out[239]:





<unittest.runner.TextTestResult run=8 errors=0 failures=0>

In [240]:

    

class GetPixelsValueTest(unittest.TestCase):
    
    def test_value_negative1(self):
        self.assertEqual([[0,0,0],[0,0,0],[0,0,0]], getPixelsValue(-1)) 
        
    def test_value_0(self):
        self.assertEqual([[0,0,0],[0,0,0],[0,0,0]], getPixelsValue(0)) 
        
    def test_value_15(self):
        self.assertEqual([[140,140,255],[0,0,0],[0,0,0]], getPixelsValue(.15)) 
        
    def test_value_11(self):
        self.assertEqual([[171,171,255],[0,0,0],[0,0,0]], getPixelsValue(.11)) 
        
    def test_value_33333(self):
        self.assertEqual([[0,0,255],[0,0,0],[0,0,0]], getPixelsValue(.33333)) 
        
    def test_value_33334(self):
        self.assertEqual([[0,0,255],[255,255,255],[0,0,0]], getPixelsValue(.3334)) 
        
    def test_value_5(self):
        self.assertEqual([[0,0,255],[127,127,255],[0,0,0]], getPixelsValue(.5)) 
        
    def test_value_65(self):
        self.assertEqual([[0,0,255],[13,13,255],[0,0,0]], getPixelsValue(.65)) 
    
    def test_value_66666(self):
        self.assertEqual([[0,0,255],[0,0,255],[0,0,0]], getPixelsValue(2.0/3.0)) 
        
    def test_value_67(self):
        self.assertEqual([[0,0,255],[0,0,255],[252,252,255] ], getPixelsValue(.67)) 
        
    def test_value_8(self):
        self.assertEqual([[0,0,255],[0,0,255],[153,153,255] ], getPixelsValue(.8)) 
        
    def test_value_99(self):
        self.assertEqual([[0,0,255],[0,0,255],[8,8,255] ], getPixelsValue(.99)) 
        
    def test_value_one(self):
        self.assertEqual([[0,0,255],[0,0,255],[0,0,255] ], getPixelsValue(1)) 
        
    def test_value_one1(self):
        self.assertEqual([[0,0,255],[0,0,255],[0,0,255] ], getPixelsValue(1.1))


    

In [241]:

    

suite = unittest.TestLoader().loadTestsFromTestCase(GetPixelsValueTest)
unittest.TextTestRunner(verbosity=2).run(suite)


    

    




test_value_0 (__main__.GetPixelsValueTest) ... ok
test_value_11 (__main__.GetPixelsValueTest) ... ok
test_value_15 (__main__.GetPixelsValueTest) ... ok
test_value_33333 (__main__.GetPixelsValueTest) ... ok
test_value_33334 (__main__.GetPixelsValueTest) ... ok
test_value_5 (__main__.GetPixelsValueTest) ... ok
test_value_65 (__main__.GetPixelsValueTest) ... ok
test_value_66666 (__main__.GetPixelsValueTest) ... ok
test_value_67 (__main__.GetPixelsValueTest) ... ok
test_value_8 (__main__.GetPixelsValueTest) ... ok
test_value_99 (__main__.GetPixelsValueTest) ... ok
test_value_negative1 (__main__.GetPixelsValueTest) ... ok
test_value_one (__main__.GetPixelsValueTest) ... ok
test_value_one1 (__main__.GetPixelsValueTest) ... ok

----------------------------------------------------------------------
Ran 14 tests in 0.017s

OK






    
Out[241]:





<unittest.runner.TextTestResult run=14 errors=0 failures=0>

In [2]:

    

import sys
sys.path.insert(0, '../calibrate_sense_hat')
sys.path.insert(0, '../test/mocks/sense_hat')

from sense_hat import SenseHat
from calibrate_sense_hat import BlxSenseHat


    

In [3]:

    

sense = SenseHat()
blxsense = BlxSenseHat()


    

In [3]:

    

sense.rotation


    

    
Out[3]:





0

In [3]:

    

probs = blxsense._predict_direction([[15,30,30]])
print probs


    

    





AttributeErrorTraceback (most recent call last)
<ipython-input-3-43fe3c0d624a> in <module>()
----> 1 probs = blxsense._predict_direction([[15,30,30]])
      2 print probs

C:\Users\brlamore\src\python-calibrate-sense-hat\calibrate_sense_hat\calibrate_sense_hat.py in _predict_direction(self, orientation)
    196     def _predict_direction(self, orientation):
    197 
--> 198         probs = self._clf.predict_proba(orientation)
    199 
    200         return probs

AttributeError: 'BlxSenseHat' object has no attribute '_clf'

In [11]:

    

for prob in probs[0]:
    pixels = blxsense._getPixelsValue(prob)
    print pixels
# pixels


    

    




[[179, 179, 255], [0, 0, 0], [0, 0, 0]]
[[179, 179, 255], [0, 0, 0], [0, 0, 0]]
[[0, 0, 255], [51, 51, 255], [0, 0, 0]]
[[102, 102, 255], [0, 0, 0], [0, 0, 0]]

In [12]:

    

blxsense._set_predicted_pixels(probs)


    

    




3 3 [179, 179, 255]
3 2 [0, 0, 0]
3 1 [0, 0, 0]
4 3 [179, 179, 255]
5 3 [0, 0, 0]
6 3 [0, 0, 0]
4 4 [0, 0, 255]
4 5 [51, 51, 255]
4 6 [0, 0, 0]
3 4 [102, 102, 255]
2 4 [0, 0, 0]
1 4 [0, 0, 0]

In [5]:

    

blxsense._show_prediction([[15,30,30]])


    

    




3 3 [179, 179, 255]
3 2 [0, 0, 0]
3 1 [0, 0, 0]
4 3 [179, 179, 255]
5 3 [0, 0, 0]
6 3 [0, 0, 0]
4 4 [0, 0, 255]
4 5 [51, 51, 255]
4 6 [0, 0, 0]
3 4 [102, 102, 255]
2 4 [0, 0, 0]
1 4 [0, 0, 0]

In [163]:

    

def convert_orientation(orientation, shift=0):
    
    orientation = np.array([raw_orientation['pitch'], raw_orientation['roll'], raw_orientation['yaw'],  ])
       
    orientation = np.round(orientation).astype(int)
    idx = np.where(orientation >180)
    orientation[idx] = orientation[idx] - 360
    orientation[-1]  = 90 - orientation[-1]  
    
    return orientation


    

In [178]:

    

class Convert_orientationTest(unittest.TestCase):
    
    def test_value_negative1(self):
        self.assertSequenceEqual(convert_orientation({'pitch': 4.543015803, 'roll': 331.0217818, 'yaw': 119.975442}), [1,2,3])


    

In [179]:

    

suite = unittest.TestLoader().loadTestsFromTestCase(Convert_orientationTest)
unittest.TextTestRunner(verbosity=2).run(suite)


    

    




test_value_negative1 (__main__.Convert_orientationTest) ... ERROR

======================================================================
ERROR: test_value_negative1 (__main__.Convert_orientationTest)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "<ipython-input-178-83364bee91ed>", line 4, in test_value_negative1
    self.assertSequenceEqual(convert_orientation({'pitch': 4.543015803, 'roll': 331.0217818, 'yaw': 119.975442}), [1,2,3])
  File "C:\Users\brlamore\AppData\Local\Continuum\Anaconda2\lib\unittest\case.py", line 663, in assertSequenceEqual
    if seq1 == seq2:
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

----------------------------------------------------------------------
Ran 1 test in 0.001s

FAILED (errors=1)






    
Out[179]:





<unittest.runner.TextTestResult run=1 errors=1 failures=0>

In [15]:

    

raw_orientation = {'pitch': 4.543015803, 'roll': 331.0217818, 'yaw': 119.975442}
raw_orientation = {'pitch': 5.002993612, 'roll': 34.52596763, 'yaw': 113.5100396}
raw_orientation


    

    
Out[15]:





{'pitch': 5.002993612, 'roll': 34.52596763, 'yaw': 113.5100396}

In [16]:

    

orientation = blxsense.convert_orientation(raw_orientation)
orientation


    

    
Out[16]:





array([  5,  35, -24])

In [17]:

    

probs = blxsense._predict_direction(orientation.reshape(1,-1))
probs


    

    
Out[17]:





array([[ 0. ,  0. ,  0.8,  0.2]])

In [18]:

    

blxsense._set_predicted_pixels([[ 0.9,  0.1,  0. ,  0. ]])


    

    




3 3 [0, 0, 255]
3 2 [0, 0, 255]
3 1 [76, 76, 255]
4 3 [179, 179, 255]
5 3 [0, 0, 0]
6 3 [0, 0, 0]
4 4 [0, 0, 0]
4 5 [0, 0, 0]
4 6 [0, 0, 0]
3 4 [0, 0, 0]
2 4 [0, 0, 0]
1 4 [0, 0, 0]

In [ ]: