class Example(QMainWindow):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setGeometry(300, 300, 300, 200)
self.setWindowTitle('Camera')
self.show()
self.camera = Camera(1)
self.camera.initialize()
self.central_widget = QWidget()
self.layout = QVBoxLayout(self.central_widget)
#define data capture button
self.button_frame = QPushButton('Capture', self.central_widget)
self.button_frame.clicked.connect(self.update_image)
self.layout.addWidget(self.button_frame)
#define image view widget
self.image_view = ImageView()
self.layout.addWidget(self.image_view)
#add central widget
self.setCentralWidget(self.central_widget)
def update_image(self):
frame = self.camera.get_frame()
self.image_view.setImage(frame.T)
print('Maximum in frame: {}, Minimum in frame: {}'.format(
np.max(frame), np.min(frame)))
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.set_minimum_size(300, 200)
self.keys = key.KeyStateHandler()
self.push_handlers(self.keys)
self.gl_init()
pyglet.clock.schedule(self.update)
self.models = []
# self.add_models(Cube(1, [0,10,0], ('c3f', (1,1,1)*4)))
# self.add_models(Cube(2, [2,20,0], ('c3f', (0,1,1)*4)))
# self.add_models(Cube(2, [1,40,1], ('c3f', (1,1,0)*4)))
self.add_models(Cube(2, [0, 0, 0], ('c3f', (1, 1, 0) * 4)))
self.add_models(Cube(2, [0, 0, 10], ('c3f', (1, 1, 1) * 4)))
self.models[0].haccel = [0.0, 0.0, 5.0]
self.models[1].haccel = [0.0, 0.0, -5.0]
self.add_models(Cube(2, [10, 0, 0], ('c3f', (1, 1, 0) * 4)))
self.add_models(Cube(2, [20, 0, 0], ('c3f', (1, 1, 1) * 4)))
self.models[2].haccel = [5.0, 0.0, 0.0]
self.models[3].haccel = [-5.0, 0.0, 0.0]
self.add_models(Cube(2, [5, 30, 0], ('c3f', (1, 1, 0) * 4)))
self.add_models(Cube(2, [5, 0, 0], ('c3f', (1, 1, 1) * 4)))
self.camera = Camera()
self.ground = Ground()
self.light = Light()
def addCamera():
response = None
content = json.loads(request.json)
if checkForUser(str(content["user_name"])) is True:#, content["password"])
newCam = Camera(cam_id='c00001', location=content["location"], owner=content["user_name"])
newCam.put()
response = json.dumps({"result": "cam_added"})
return response
else:
return content["user_name"]
def cadastro_camera():
identificador = request.form["identificador"]
rua = request.form["rua"]
numero = request.form["numero"]
bairro = request.form["bairro"]
complemento = request.form["complemento"]
cidade = request.form["cidade"]
UF = request.form["UF"]
nova_camera = Camera(identificador=identificador,
rua=rua,
numero=numero,
bairro=bairro,
complemento=complemento,
cidade=cidade,
UF=UF)
nova_camera.save()
return redirect("/perfil")
def __init__(self):
self._screen_size = (400, 400)
self._center = (self._screen_size[0] // 2, self._screen_size[1] // 2)
self._screen = None
self._clock = None
self._background = (128, 128, 255)
self._title = None
self._model_manager = None
self._camera = Camera()
def add_camera():
camera = Camera(
id=-1,
name=request.json['name'],
ip=request.json['ip'],
port=request.json['port'],
)
db.add_camera(camera)
return jsonify({'camera': 'true'}), 201
def calibrate_camera():
"""This method should be called everytime the
camera_cal directory is updated
"""
images = glob.glob('camera_cal/calibration*.jpg')
camera = Camera.from_calibration_config(
uuid="cam-1",
calibration_images=images,
pattern_size=(9, 6)
)
camera.calibrate(False)
def add_camera():
params = get_json_params()
cameras = db.session.query(Camera).filter_by(place=params["place"]).all()
if len(cameras) != 0:
cameras[0].endpoint = params["endpoint"]
db.session.commit()
return "update ok"
new_camera = Camera(params["place"], params["endpoint"])
db.session.add(new_camera)
db.session.commit()
return "ok"
def edit_camera():
camera = db.get_camera(request.json['id'])
edited_camera = Camera(
id=camera['id'],
name=request.json['name'],
ip=request.json['ip'],
port=request.json['port'],
)
db.edit_camera(edited_camera)
return jsonify({'camera': 'true'})
def initUI(self):
self.setGeometry(300, 300, 300, 200)
self.setWindowTitle('Camera')
self.show()
self.camera = Camera(1)
self.camera.initialize()
self.central_widget = QWidget()
self.layout = QVBoxLayout(self.central_widget)
#define data capture button
self.button_frame = QPushButton('Capture', self.central_widget)
self.button_frame.clicked.connect(self.update_image)
self.layout.addWidget(self.button_frame)
#define image view widget
self.image_view = ImageView()
self.layout.addWidget(self.image_view)
#add central widget
self.setCentralWidget(self.central_widget)
def new():
pcfg = {"title": gettext("Add Camera")}
form = CameraAddForm()
if form.validate_on_submit():
camera = Camera()
camera.state = form.state.data
camera.state_notes = form.state_notes.data
camera.manufacturer = form.manufacturer.data
camera.model = form.model.data
camera.model_notes = form.model_notes.data
camera.description = form.description.data
camera.serial = form.serial.data
camera.mount = form.mount.data
camera.camera_type = form.camera_type.data
camera.film_type = form.film_type.data
camera.auto_expo = form.auto_expo.data
camera.auto_focus = form.auto_focus.data
camera.batteries = form.batteries.data
camera.hot_shoe = form.hot_shoe.data
camera.fixed_lens = form.fixed_lens.data
camera.iso_min = form.iso_min.data
camera.iso_max = form.iso_max.data
camera.focale_min = form.focale_min.data
camera.focale_max = form.focale_max.data
camera.min_aperture = form.min_aperture.data
camera.max_aperture = form.max_aperture.data
camera.blades = form.blades.data
camera.filter_diameter = form.filter_diameter.data
camera.weight = form.weight.data
camera.length = form.length.data
camera.focus = form.focus.data
camera.focus_length = form.focus_length.data
camera.macro = form.macro.data
camera.macro_length = form.macro_length.data
camera.private = form.private.data
camera.url1 = form.url1.data
camera.url2 = form.url2.data
camera.url3 = form.url3.data
camera.user_id = current_user.id
if "picture" in request.files:
camera.pic_filename = get_hashed_filename(
request.files["picture"].filename)
pictures.save(request.files["picture"],
folder=current_app.config["UPLOADED_PICTURES_DEST"],
name=camera.pic_filename)
db.session.add(camera)
db.session.commit()
flash("Successfully added camera.", "success")
return redirect(url_for("bp_users.cameras", name=current_user.name))
return render_template("cameras/new.jinja2", pcfg=pcfg, form=form)
class Window(pyglet.window.Window):
def setLock(self, state):
self.lock = state
self.set_exclusive_mouse(state)
lock = False
mouse_lock = property(lambda self: self.lock, setLock)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.set_minimum_size(300, 200)
self.keys = key.KeyStateHandler()
self.push_handlers(self.keys)
self.gl_init()
pyglet.clock.schedule(self.update)
self.models = []
# self.add_models(Cube(1, [0,10,0], ('c3f', (1,1,1)*4)))
# self.add_models(Cube(2, [2,20,0], ('c3f', (0,1,1)*4)))
# self.add_models(Cube(2, [1,40,1], ('c3f', (1,1,0)*4)))
self.add_models(Cube(2, [0, 0, 0], ('c3f', (1, 1, 0) * 4)))
self.add_models(Cube(2, [0, 0, 10], ('c3f', (1, 1, 1) * 4)))
self.models[0].haccel = [0.0, 0.0, 5.0]
self.models[1].haccel = [0.0, 0.0, -5.0]
self.add_models(Cube(2, [10, 0, 0], ('c3f', (1, 1, 0) * 4)))
self.add_models(Cube(2, [20, 0, 0], ('c3f', (1, 1, 1) * 4)))
self.models[2].haccel = [5.0, 0.0, 0.0]
self.models[3].haccel = [-5.0, 0.0, 0.0]
self.add_models(Cube(2, [5, 30, 0], ('c3f', (1, 1, 0) * 4)))
self.add_models(Cube(2, [5, 0, 0], ('c3f', (1, 1, 1) * 4)))
self.camera = Camera()
self.ground = Ground()
self.light = Light()
def add_models(self, model):
self.models.append(model)
def gl_init(self):
glClearColor(0.5, 0.5, 0.5, 1)
glShadeModel(GL_SMOOTH)
glEnable(GL_DEPTH_TEST)
def projection(self):
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
def modelview(self):
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
def set3d(self):
self.projection()
gluPerspective(90, self.width / self.height, 0.05, 1000)
self.modelview()
def on_mouse_motion(self, x, y, dx, dy):
if self.mouse_lock:
self.camera.mouse_motion(dx, dy)
def on_key_press(self, KEY, MOD):
if KEY == key.ESCAPE:
self.close()
elif KEY == key.Q:
self.mouse_lock = not self.mouse_lock
if KEY == key.K:
x, y, z = self.camera.pos
self.add_models(Cube(2, [x, y, z], ('c3f', (1, 1, 0) * 4)))
if KEY == key.T:
x = self.camera.pos[0]
y = self.camera.pos[1]
z = self.camera.pos[2] + 10
self.add_models(Cube(2, [x, y, z], ('c3f', (1, 1, 0) * 4)))
self.models[-1].hvel = [x, y, -z]
def update(self, dt):
self.camera.update(dt, self.keys)
for model in self.models:
model.update(dt, self.keys)
def on_draw(self):
self.clear()
draw_axis(3, (-1, 1, -1))
self.set3d()
self.camera.move()
self.light.show()
self.ground.draw()
for i in range(len(self.models)):
for j in range(len(self.models)):
if i != j:
collision(self.models[i], self.models[j])
ground_collision(self.models[i], self.ground)
for model in self.models:
model.draw()
def __init__(self, sizex, sizey):
self.camera = Camera()
self.screen = pygame.display.set_mode([sizex, sizey])
self.translation = (sizex / 2, sizey / 2)
def reject(self): camera = Camera(0) self.hide() self.main_window.show()
from PyQt5.QtWidgets import QApplication from models import Camera from views import StartWindow camera = Camera(1) camera.initialize() app = QApplication([]) start_window = StartWindow(camera) start_window.show() app.exit(app.exec_())
def node_discover(request):
g_logger.debug('Node Discover %s' % request.data['machine_name'])
# Look for existing machine in the database, with the same name
nodes = CaptureNode.objects.filter(
machine_name=request.data['machine_name'])
if nodes:
# Node exists in database, update it
node = nodes[0]
node.ip_address = request.data['ip_address']
node.last_seen = timezone.now()
else:
# Node does not exist, create it
node = CaptureNode(ip_address=request.data['ip_address'],
machine_name=request.data['machine_name'])
if 'sync_found' in request.data:
node.sync_found = request.data['sync_found']
if 'os' in request.data:
node.os = request.data['os']
node.online = True
node.code_version = request.data[
'code_version'] if 'code_version' in request.data else 0
if node.code_version < 1024:
return JSONResponse({'Result': 'avacapture.exe Version Too Old'},
status=426)
# Update drive info
if 'drives' in request.data:
node.drive_info = json.dumps(request.data['drives'])
node.save()
# Update list of cameras
if 'cameras' in request.data:
# TODO We should be getting each cameras Model and Version here, to update the DB
if type(request.data) is dict:
cam_list = request.data['cameras']
else:
cam_list = request.data.getlist('cameras')
for unique_id in cam_list:
# if camera does no exist, create it
obj = Camera.objects.filter(unique_id=unique_id, node=node)
if not obj:
obj = Camera(node=node, unique_id=unique_id)
obj.save()
# delete any cameras that are not in the list
for item in Camera.objects.filter(node=node).exclude(
unique_id__in=cam_list):
item.delete()
if node.location:
result = {
'Result': 'OK',
'sync_freq': node.location.hardware_sync_frequency,
'pulse_duration': node.location.pulse_duration,
'external_sync': node.location.external_sync,
'display_focus_peak': node.location.display_focus_peak,
'display_overexposed': node.location.display_overexposed,
'display_histogram': node.location.display_histogram,
'bitdepth_avi': node.location.bitdepth_avi,
'bitdepth_single': node.location.bitdepth_single
}
else:
return HttpResponse("Node not registered", status=403)
if 'request_camera_params' in request.data:
# client is requesting the current parameters of the cameras
cameras = Camera.objects.filter(node=node)
# TODO Generalize DB for parameters
result['camera_params'] = [
dict(unique_id=cam.unique_id,
lens_aperture_value=cam.lens_aperture,
exposure=cam.exposure,
gain=cam.gain,
using_sync=cam.using_sync) for cam in cameras
]
# TODO Camera roi
# return JSON data for the current machine
return JSONResponse(result)
def run(self):
self.recognize_using_websocket([])
#app
app = QtWidgets.QApplication([])
window = uic.loadUi("main.ui")
window.setWindowTitle("Final Project")
window.show()
#timer
timer_thread = TimerThread(window)
timer_thread.start()
timer_thread.pause()
#webcam
camera = Camera(CAMERA_ID, CAMERA_WIDTH, CAMERA_HEIGHT)
#video thread
videoThread = VideoThread(camera, window)
videoThread.signal.connect(update)
videoThread.signalMood.connect(getMood)
videoThread.start()
#microphone thread
recognize_thread = SpeechThread(window)
recognize_thread.start()
window.durationLineEdit.setText(str(DEFAULT_DURATION))
window.thresholdLineEdit.setText(str(DEFAULT_THRESHOLD))
window.captureTextLabel.setText("Captured text...")
window.translatedTextLabel.setText("Translated text...")
window.disfluencyCountLabel.setText("0")
class Engine():
keys_pressed = set()
def __init__(self, sizex, sizey):
self.camera = Camera()
self.screen = pygame.display.set_mode([sizex, sizey])
self.translation = (sizex / 2, sizey / 2)
def handleTask(self, task):
return {DrawLineTask: self.drawLine}[type(task)](task)
def drawLine(self, task):
start = (task.start[0] + self.translation[0],
task.start[1] + self.translation[1])
end = (task.end[0] + self.translation[0],
task.end[1] + self.translation[1])
pygame.draw.line(self.screen, task.color, start, end, LINE_WIDTH)
def handleTranslations(self, event):
if pygame.K_LEFT in self.keys_pressed:
self.camera.translateX(-TRANSLATION_SPEED)
if pygame.K_RIGHT in self.keys_pressed:
self.camera.translateX(TRANSLATION_SPEED)
if pygame.K_PAGEUP in self.keys_pressed:
self.camera.translateY(-TRANSLATION_SPEED)
if pygame.K_PAGEDOWN in self.keys_pressed:
self.camera.translateY(TRANSLATION_SPEED)
if pygame.K_UP in self.keys_pressed:
self.camera.translateZ(TRANSLATION_SPEED)
if pygame.K_DOWN in self.keys_pressed:
self.camera.translateZ(-TRANSLATION_SPEED)
def handleRotations(self, event):
if pygame.K_w in self.keys_pressed:
self.camera.rotateX(-ROTATION_SPEED)
if pygame.K_s in self.keys_pressed:
self.camera.rotateX(ROTATION_SPEED)
if pygame.K_d in self.keys_pressed:
self.camera.rotateY(-ROTATION_SPEED)
if pygame.K_a in self.keys_pressed:
self.camera.rotateY(ROTATION_SPEED)
if pygame.K_q in self.keys_pressed:
self.camera.rotateZ(-ROTATION_SPEED)
if pygame.K_e in self.keys_pressed:
self.camera.rotateZ(ROTATION_SPEED)
def handleZooming(self, event):
if pygame.K_z in self.keys_pressed:
self.camera.changeZoom(self.camera.zoom * ZOOMSPEED)
if pygame.K_x in self.keys_pressed:
self.camera.changeZoom(-self.camera.zoom * ZOOMSPEED)
def run(self):
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
self.keys_pressed.add(event.key)
elif event.type == pygame.KEYUP:
self.keys_pressed.remove(event.key)
self.handleTranslations(event)
self.handleRotations(event)
self.handleZooming(event)
self.screen.fill((0, 0, 0))
tasks = self.camera.getTasks()
for task in tasks:
self.handleTask(task)
#pygame.draw.line(self.screen, (255,255,255), (0,0), (250, 250), 2)
#pygame.draw.circle(self.screen, (0, 0, 255), (250, 250), 75)
pygame.display.flip()
pygame.quit()
from PyQt5.QtWidgets import QApplication from models import Camera from Spectrometer import Spectrometer from views import StartWindow camera = Camera(0) camera.initialize() spectrometer = Spectrometer() spectrometer.connect() app = QApplication([]) start_window = StartWindow(camera, spectrometer) # start_window = StartWindow(camera) start_window.show() app.exit(app.exec_()) spectrometer.disconnect() camera.close_camera()
from PyQt5.QtWidgets import QApplication from models import Camera from views import StartWindow camera = Camera(0) # camera.initialize() app = QApplication([]) start_window = StartWindow(camera) start_window.show() app.exit(app.exec_())