Committing deletes, updating .gitignore

5 files changed, 6 insertions, 310 deletions

diff --git a/.gitignore b/.gitignore
index ded6067..fcde8e2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,3 +34,9 @@ nosetests.xml
 .mr.developer.cfg
 .project
 .pydevproject
+
+# Logs
+.log
+
+# compiled files
+.pyc
diff --git a/random241.py b/random241.py
deleted file mode 100755
index 47bdff7..0000000
--- a/random241.py
+++ /dev/null
@@ -1,67 +0,0 @@
-#!/usr/bin/python2
-
-import cv
-import time
-import numpy as np
-import logging
-import random241arg as arg
-import random241sensor as sensor
-import random241osc as osc
-
-showStream = False
-stop_key = 0
-capture = True
-camNumber = 1
-time_delta = 60 * 60 / 2
-logging.basicConfig(filename='random241.log',
-                    format='%(asctime)s %(message)s',
-                    filemode='w', level=logging.INFO)
-last_time = time.time()
-
-# Read parameters
-params = arg.read_params()
-# Define which cam to use, etc.
-#cam = sensor.capture(params['-c'], showStream)
-
-# Get frame and size information from camera
-cam = cv.CaptureFromCAM(camNumber)
-frame = cv.QueryFrame(cam)
-if frame is not None:
-    frame_size = cv.GetSize(frame)
-    logging.info('Grabbing random numbers from: %dx%dpx.',
-                 frame_size[0], frame_size[1])
-
-    # Get matrix with values from frame
-    mat = cv.GetMat(frame)
-    frame_values = np.asarray(mat)
-    # Create grayscale image
-    gray_values = sensor.bgr2gray(frame_values)
-
-    # Define the time to run the test
-    time_delta = time_delta + time.time()
-
-    # Setup OSC
-    osc.connect_to_server("127.0.0.1", 57120)
-
-    # Main loop for accessing the camera and calculating random numbers from it
-    #while True:
-    while time_delta > time.time():
-#        last_time = time.time()
-        img = cv.QueryFrame(cam)
-        # Get a numpy array with rgb values
-        mat_from_frame = sensor.frame_to_mat(img)
-        gray_mat = sensor.bgr2gray(mat_from_frame)
-        randomness = sensor.harvest_entropy(gray_mat)
-        if randomness is not None:
-            delta = time.time() - last_time
-            last_time = time.time()
-            osc.send_msg(delta, randomness)
-        if showStream:
-            while stop_key != ord("q"):
-                cv.ShowImage("Americium 241", img)
-                key = cv.WaitKey(2)
-
-    #time.sleep(5)
-    #random241sensor.set_capture(False)
-else:
-    logging.error('Connect camera %d first!', camNumber)
diff --git a/random241arg.py b/random241arg.py
deleted file mode 100755
index 4bd00d8..0000000
--- a/random241arg.py
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/usr/bin/python2
-
-from sys import argv
-
-
-def read_params():
-    # Checks the given parameters
-    info = """Use the program as following:
-    random241.py [option] <param> ...
-    Options:
-        -c  number of cam to use (starts with first found camera 0 (default))
-        -r  remote address to send the output to (standard 192.168.0.7)
-    """
-    default = {'-c': "1", '-r': "192.168.0.7"}
-    parameters = default.copy()
-    if len(argv) != 3:
-        for i in xrange(1, len(argv) - 1, 2):
-            if argv[i] in parameters:
-                parameters[argv[i]] = argv[i + 1]
-            else:
-                print info
-                return 0
-        return parameters
-    else:
-        return default
diff --git a/random241osc.py b/random241osc.py
deleted file mode 100755
index 1e06917..0000000
--- a/random241osc.py
+++ /dev/null
@@ -1,32 +0,0 @@
-#import OSC as osc
-import liblo as osc
-import logging
-
-# Declare an empty target
-target = None
-
-
-# Connect to the server
-def connect_to_server(hostname, port):
-    global target
-    if (hostname or port) is None:
-        target = osc.Adress('127.0.0.1', 57121, osc.UDP)
-    else:
-        try:
-            target = osc.Address(hostname, port, osc.UDP)
-        except osc.AddressError, err:
-            logging.error(err)
-
-
-# Send a osc_message to the server
-def send_msg(time_delta, randomness):
-    global target
-    # if the message is not empty and longer than 1
-    if randomness is not None and len(randomness) > 1:
-        msg = osc.Message("/random")
-        msg.add(time_delta)
-        msg.add(randomness[0], randomness[1])
-        try:
-            osc.send(target, msg)
-        except:
-            logging.error('OSC: Sending of message failed.')
diff --git a/random241sensor.py b/random241sensor.py
deleted file mode 100755
index e9525e4..0000000
--- a/random241sensor.py
+++ /dev/null
@@ -1,186 +0,0 @@
-#!/usr/bin/python2
-
-import logging
-import cv
-import numpy as np
-import time
-
-# Bool to define wether to capture the cam or not
-capture = True
-# Bool to define wether to show the capture stream or not
-showStream = True
-white_threshold = 15.0
-checked = np.zeros((1, 1), dtype=np.int)
-mat = np.zeros((1, 1))
-clusters = []
-balances = []
-
-
-def capture(camNumber, showStream):
-    # Open stream for that camera
-    logging.info('Capture from camera #%d', camNumber)
-    cam = cv.CaptureFromCAM(int(camNumber))
-    # Stream to output window as long as it is active
-    return cam
-    while capture:
-        stream = cv.QueryFrame(cam)
-        if showStream:
-            cv.ShowImage("Americium 241", stream)
-
-
-def set_capture(onOrOff):
-    if onOrOff == bool:
-        global capture
-        capture = onOrOff
-
-
-def frame_to_mat(img):
-    cv.Smooth(img, img, cv.CV_GAUSSIAN, 3, 0)
-    mat = cv.GetMat(img)
-    frame_values = np.asarray(mat)
-    return frame_values
-
-
-# Convert a bgr matrix to grayscale
-def bgr2gray(mat):
-    b, g, r = mat[:, :, 0], mat[:, :, 1], mat[:, :, 2]
-    gray = 0.1140 * b + 0.5870 * g + 0.2989 * r
-    return gray
-
-
-# Find a white dot in the black input matrix
-def harvest_entropy(mat_input):
-    global mat
-    global checked
-    global clusters
-    global balances
-    mat = mat_input.copy()
-    if np.ndim(mat) >= 2:
-        # Create array to hold the already checked pixels
-        checked = np.zeros((len(mat), len(mat[0])), dtype=np.int)
-        # Traverse the grayscale values in search of a bright pixel
-        for i in range(0, len(mat) - 1):
-            for j in range(0, len(mat[0]) - 1):
-                # Check if it hasn't been checked yet
-                if (checked[i][j] != 1):
-                    # Find clusters, if the pixel is above threshold
-                    if (mat[i][j] >= white_threshold):
-                        #print "Hit above white threshold"
-                        # Add a new cluster to the list of clusters
-                        cluster = []
-                        clusters.append(cluster)
-                        # Find the rest of the cluster
-                        find_cluster(i, j)
-                        #print "Number at: %dx%dpx : %s" % (j, i, mat[i][j])
-                checked[i][j] = 1
-        # If there's one or more clusters, calculate its or their balance point
-        if len(clusters) > 0:
-            balance_point = cluster_to_balance_point()
-            logging.info('%s, %s', balance_point[1], balance_point[0])
-            #print balance_point
-            # Empty the global clusters variable again
-            del clusters[:]
-            balances.append([time.time(), balance_point])
-            mean = mean_balances()
-            logging.info('%s, %s (balance mean)', mean[1], mean[0])
-            floats = coordinate_to_float(balance_point[0], balance_point[1])
-            logging.info('%s, %s (float)', floats[1], floats[0])
-            #return balance_point
-            return floats
-    else:
-        logging.error('Input matrix has wrong dimension!')
-
-
-# Find cluster around a non-black pixel
-def find_cluster(x, y):
-    global checked
-    global mat
-    global clusters
-    # Append the current white dot to the last cluster
-    dot = np.array([x, y, mat[x][y]])
-    clusters[len(clusters) - 1].append(dot)
-    # Search for surrounding white dots now
-    # Search one pixel further right
-    if (len(mat) - 1 >= (x + 1)) and (mat[x + 1][y] >= white_threshold) \
-            and (checked[x + 1][y] != 1):
-        find_cluster(x + 1, y)
-    # Search one pixel further right and down
-    if (len(mat) - 1 >= (x + 1)) and (len(mat[0]) - 1 >= y + 1) and \
-            (mat[x + 1][y + 1] >= white_threshold) \
-            and (checked[x + 1][y] != 1):
-        find_cluster(x + 1, y + 1)
-    # Search one pixel further down
-    if (len(mat[0]) - 1 >= y + 1) and \
-            (mat[x][y + 1] >= white_threshold) and (checked[x][y + 1] != 1):
-        find_cluster(x, y + 1)
-    # Search one pixel further down and further left
-    if (len(mat[0]) - 1 >= y + 1) and x - 1 >= 0 \
-            and (mat[x - 1][y + 1] >= white_threshold) \
-            and (checked[x - 1][y + 1] != 1):
-        find_cluster(x - 1, y + 1)
-    # Add this pixel to the list of checked pixels
-    checked[x][y] = 1
-
-
-# Create balance point from cluster
-# TODO: Make possible to choose only most significant cluster
-def cluster_to_balance_point():
-    global clusters
-    cluster_balances = []
-    x_balance = 0.0
-    y_balance = 0.0
-    for cluster in clusters:
-        mean_x = 0.0
-        mean_y = 0.0
-        sum_total = 0.0
-        for dot in cluster:
-            # Calculate X balance (x * intensity)
-            mean_x = mean_x + dot[0] * dot[2]
-            # Calculate Y balance (y * intensity)
-            mean_y = mean_y + dot[1] * dot[2]
-            # Calculate Y total (all intensity summed up)
-            sum_total = sum_total + dot[2]
-        # Add up the balances and put them into a list
-        cluster_x_balance = mean_x / sum_total
-        cluster_y_balance = mean_y / sum_total
-        cluster_balances.append([cluster_x_balance, cluster_y_balance])
-    # If it's more than one cluster, balance between them
-    if len(cluster_balances) > 1:
-        logging.info('Balancing between a couple of clusters.')
-        total_cluster_x_balance = 0.0
-        total_cluster_y_balance = 0.0
-        for balance in cluster_balances:
-            total_cluster_x_balance = total_cluster_x_balance + balance[0]
-            total_cluster_y_balance = total_cluster_y_balance + balance[1]
-        x_balance = total_cluster_x_balance / float(len(cluster_balances))
-        y_balance = total_cluster_y_balance / float(len(cluster_balances))
-    else:
-        logging.info('Balancing between one cluster.')
-        x_balance = cluster_x_balance
-        y_balance = cluster_y_balance
-    return [x_balance, y_balance]
-
-
-# Displays the mean balance calculated from all balances
-def mean_balances():
-    global balances
-    mean_balance = [0.0, 0.0]
-    for balance in balances:
-        mean_balance[0] = mean_balance[0] + balance[1][0]
-        mean_balance[1] = mean_balance[1] + balance[1][1]
-    mean_balance[0] = mean_balance[0] / float(len(balances))
-    mean_balance[1] = mean_balance[1] / float(len(balances))
-    return mean_balance
-
-
-# Calculates float value between 0.0 and 1.0 from coordinate
-# TODO: insert on-the-fly mean_balance as parameter
-def coordinate_to_float(x, y):
-    global mat
-    width = float(len(mat))
-    height = float(len(mat[0]))
-#    balance_dim = [width / 2, height / 2]
-    floatx = x / width
-    floaty = y / height
-    return [floatx, floaty]
-# TODO: Function to calculate floats from mean_balance on the fly