/
matetv.py
173 lines (131 loc) · 6.09 KB
/
matetv.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
#!/usr/bin/env python2.7
from PyQt4 import QtCore, QtGui, Qt, QtNetwork
from PyQt4.QtGui import QApplication, QLineEdit, QTableWidget, QTableWidgetItem, QWidget, QVBoxLayout, QFileDialog
from gui import Ui_Form
import struct
import time
import sys
import cv
import socket
IP = "matelight.cbrp3.c-base.org"
PORT = 1337
RESX = 40
RESY = 16
KAMERA_NR = 0
TOTAL_PIXELS = RESX * RESY
FRAMES_PER_SECOND = 50
TIME_BETWEEN_FRAMES = 1.0 / FRAMES_PER_SECOND
class MyForm(QtGui.QMainWindow):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_Form()
self.ui.setupUi(self)
QtCore.QObject.connect(self.ui.pushButton_stream_webcam, QtCore.SIGNAL("clicked()"), self.cmd_stream_webcam)
QtCore.QObject.connect(self.ui.horizontalSlider_fps, QtCore.SIGNAL("valueChanged(int)"), self.cmd_fps_changed)
QtCore.QObject.connect(self.ui.verticalSlider_red, QtCore.SIGNAL("valueChanged(int)"), self.cmd_red_slider_changed)
QtCore.QObject.connect(self.ui.verticalSlider_green, QtCore.SIGNAL("valueChanged(int)"), self.cmd_green_slider_changed)
QtCore.QObject.connect(self.ui.verticalSlider_blue, QtCore.SIGNAL("valueChanged(int)"), self.cmd_blue_slider_changed)
QtCore.QObject.connect(self.ui.verticalSlider_gamma, QtCore.SIGNAL("valueChanged(int)"), self.cmd_gamma_slider_changed)
QtCore.QObject.connect(self.ui.verticalSlider_brightness, QtCore.SIGNAL("valueChanged(int)"), self.cmd_brightness_slider_changed)
# Network init
self.sock = QtNetwork.QUdpSocket()
self.sock.bind(QtNetwork.QHostAddress.Any, PORT)
self.connect(self.sock, QtCore.SIGNAL("readyRead()"), self.on_recv_udp_packet)
self.image = None
self.streaming = False
self.threshold = 128
self.equalize = False
self.fps = FRAMES_PER_SECOND
self.time_between_frames = TIME_BETWEEN_FRAMES
self.cam = cv.CaptureFromCAM(KAMERA_NR)
self.max_red = 100
self.max_green = 100
self.max_blue = 100
self.max_gamma = 100
self.max_brightness = 100
def cv_load_image(self, file_path):
image = cv.LoadImage(file_path)
conv_img = self.cv_get_converted_image_for_matelight(image)
return conv_img
def convert_img_matrix_to_matelight(self, mat):
bitstring = []
for row in xrange(mat.rows):
for column in xrange(mat.cols):
red = int(mat[row, column][2] * self.max_red / 100.0)
green = int(mat[row, column][1] * self.max_green / 100.0)
blue = int(mat[row, column][0] * self.max_blue / 100.0)
bitstring.extend(struct.pack('BBB', red, green, blue))
return bytearray(bitstring)
def cv_resize_and_grayscale(self, input_image, threshold, doEqualize):
image = cv.CreateImage((input_image.width, input_image.height), 8, 1)
cv.CvtColor(input_image, image, cv.CV_BGR2GRAY)
if doEqualize:
cv.EqualizeHist(image, image) # equalize the pixel brightness
cv.Threshold(image, image, threshold, 255, cv.CV_THRESH_OTSU) # convert to black / white image
image_resized = cv.CreateImage( (RESX, RESY), image.depth, image.channels) # resize to fit into r0ket display
cv.Resize(image, image_resized, cv.CV_INTER_NN)
return image_resized
# GUI events
def cmd_load_image(self):
file_path = str(self.ui.lineEdit_file_path.text())
self.image = self.cv_load_image(file_path)
print "image loaded!"
def cmd_stream_webcam(self):
end_time = 0
counter = 1
while True:
frame = cv.QueryFrame(self.cam)
c = cv.WaitKey(1)
if c == 27: # esc
return
g = cv.CreateImage(cv.GetSize (frame), cv.IPL_DEPTH_8U, frame.channels)
gr = frame[128: 384, 0: 640] # Crop from x, y, w, h -> 100, 200, 100, 200
ml = cv.CreateImage((40, 16), cv.IPL_DEPTH_8U, frame.channels)
cv.Resize(gr, ml)
cv.ShowImage("Matelight TV", gr)
if time.time() > end_time:
end_time = time.time() + self.time_between_frames
#self.cmd_send_image(ml, 0.25, 2)
self.cmd_send_image(ml, self.max_brightness, self.max_gamma)
print counter
counter += 1
def cmd_send_image(self, image, brightness, gamma):
mg_mat = cv.GetMat(image)
ml_data = self.convert_img_matrix_to_matelight(mg_mat) + "\00\00\00\00"
data_c = bytearray([int(((x / 255.0) ** (gamma / 100.0)) * 255 * (brightness / 100.0)) for x in list(ml_data)])
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.sendto(data_c, (IP, PORT))
def cmd_fps_changed(self, value):
self.fps = value
self.time_between_frames = 1.0 / self.fps
def cmd_red_slider_changed(self, value):
self.max_red = value
print "red slider changed to %d %%" % value
def cmd_green_slider_changed(self, value):
self.max_green = value
print "green slider changed to %d %%" % value
def cmd_blue_slider_changed(self, value):
self.max_blue = value
print "blue slider changed to %d %%" % value
def cmd_gamma_slider_changed(self, value):
self.max_gamma = value
print "gamma slider changed to %d %%" % value
def cmd_brightness_slider_changed(self, value):
self.max_brightness = value
print "brightness slider changed to %d %%" % value
def cmd_equalize_changed(self, state):
self.equalize = state
print state
def cmd_browse_file(self):
self.ui.lineEdit_file_path.setText(QFileDialog.getOpenFileName())
def send_udp_packet(self, payload):
self.sock.writeDatagram(payload, QtNetwork.QHostAddress(IP), PORT)
def on_recv_udp_packet(self):
print "UDP packet received but ignored. TODO: implement handler."
def main():
app = QtGui.QApplication(sys.argv)
myapp = MyForm()
myapp.show()
sys.exit(app.exec_())
if __name__ == "__main__":
main()