def captureMovie(duration,save_dir = None):
cam = Camera()
if not save_dir:
save_dir = raw_input('Input movie directory')
if not os.path.exists(save_dir): os.mkdir(save_dir)
if save_dir[-1] != '\\': save_dir = save_dir+'\\'
cnt = 0
sample_rate = 30
num_frames = sample_rate*duration
frames = []
start = time.clock()
last = time.clock()
for i in range(num_frames):
frames.append(cam.getFrameImage())
## wait for sample time
now = time.clock()
while (now - last) < (1./sample_rate):
now = time.clock()
last = now
clocked_time = now - start #- 1./sample_rate
for i,frame in enumerate(frames):
if i < 10:
zeros = '00'
elif i < 100:
zeros = '0'
else:
zeros = ''
frame.save(save_dir+'mov'+ zeros + str(i)+'.bmp')
print 'Movie saved. Clocked duration = ' + str(clocked_time)
cam.close()
def run(self):
self.logger.info("starting preview")
while self.run_thread:
try:
self.camera_loop(self.camera)
except Exception:
self.camera = Camera()
logging.error("Camera has error")
def __init__(self, session_service):
QThread.__init__(self)
self.logger = logging.getLogger()
self.logger.info("Starting camera tread")
self.run_thread = True
self.trigger = False
self.session_dir = None
self.session_service = session_service
self.preview_is_aktive = True
self.camera = Camera()
self.logger.info("init of camara thread done ")
def parse(self, cmd):
tokens = shlex.split(cmd)
first_token = tokens.pop(0)
# If first argument is a device, assume an action is coming
device = self.station.find_device_by_name(first_token)
if device:
action = tokens.pop(0)
device.do_action(action, tokens)
# Generic actions
if first_token == "add":
device_type = tokens.pop(0)
device_name = tokens.pop(0)
if device_type == 'videotestgen':
videotestgen = VideoTestGen(device_name)
self.station.add_device(videotestgen)
if device_type == 'camera':
camera = Camera(device_name)
self.station.add_device(camera)
if device_type == 'switcher':
inputs = int(tokens.pop(0))
switcher = Switcher(device_name, inputs)
self.station.add_device(switcher)
if device_type == 'monitor':
monitor = Monitor(device_name, (320, 240), (0, 0))
self.station.add_device(monitor)
if first_token == "remove":
device_name = tokens.pop(0)
device = self.station.find_device_by_name(device_name)
self.station.remove_device(device)
if first_token == "graph":
self.station.graph_pipeline()
if first_token == "link":
port_1, port_2 = tokens.pop(0), tokens.pop(0)
name = port_1 + "-" + port_2
self.station.link(name, port_1, port_2)
if first_token == "unlink":
port_1 = tokens.pop(0)
port_2 = tokens.pop(0)
self.station.unlink(port_1, port_2)
if first_token == "exit":
self.editor.exit()
def create_location(user, polygon, descriptive_name, zip_code):
"""Takes as input a polygon object and a string naming the location.
Returns the key of the newly created database object.
"""
private_location = PrivateLocation(user_fk=user.key,
descriptive_name=descriptive_name,
max_latitude=polygon.get_max_lat(),
min_latitude=polygon.get_min_lat(),
max_longitude=polygon.get_max_lng(),
min_longitude=polygon.get_min_lng(),
center=ndb.GeoPt(
polygon.get_center_lat(),
polygon.get_center_lng()),
polygon=polygon,
camera=Camera(),
video=Video(),
status=LocationStatus(),
zip_code=zip_code)
return private_location.put()
def create_devices(self, config: dict):
# This dict will store all created devices, subcategorized by dev_type.
self.all_devices = {}
# Create device objects by type, going through the config by type.
for dev_type in self.device_types:
self.all_devices[dev_type] = {}
# Get the names of all the devices from each dev_type.
devices_of_type = config.get(dev_type, {})
device_names = devices_of_type.keys()
# Instantiate each device object from based on its type
for name in device_names:
driver = devices_of_type[name]["driver"]
settings = devices_of_type[name].get("settings", {})
#print('looking for dev-types: ', dev_type)
if dev_type == "observing_conditions":
device = ObservingConditions(driver, name)
elif dev_type == 'enclosure':
device = Enclosure(driver, name)
elif dev_type == "mount":
device = Mount(driver, name, settings, tel=False)
elif dev_type == "telescope": #order of attaching is sensitive
device = Telescope(driver, name, settings, tel=True)
elif dev_type == "rotator":
device = Rotator(driver, name)
elif dev_type == "focuser":
device = Focuser(driver, name, self.config)
elif dev_type == "screen":
device = Screen('EastAlnitak', 'COM6')
elif dev_type == "camera":
device = Camera(driver, name, self.config) #APPARENTLY THIS NEEDS TO BE STARTED PRIOR TO FILTER WHEEL!!!
elif dev_type == "sequencer":
device = Sequencer(driver, name)
elif dev_type == "filter_wheel":
device = FilterWheel(driver, name, self.config)
else:
print(f"Unknown device: {name}")
# Add the instantiated device to the collection of all devices.
self.all_devices[dev_type][name] = device
class CameraThread(QThread):
newImage: Signal = Signal(QImage)
send_to_arduino: Signal = Signal(bytes)
send_with_delay: Signal = Signal(int)
def __init__(self, session_service):
QThread.__init__(self)
self.logger = logging.getLogger()
self.logger.info("Starting camera tread")
self.run_thread = True
self.trigger = False
self.session_dir = None
self.session_service = session_service
self.preview_is_aktive = True
self.camera = Camera()
self.logger.info("init of camara thread done ")
@Slot(str)
def set_session_dir(self, session_dir):
self.session_dir = session_dir
def __del__(self):
self.logger.info("Closing camera thread")
self.run_thread = False
self.camera.disconnect_camera()
self.logger.info("Closed camera")
self.wait()
def run(self):
self.logger.info("starting preview")
while self.run_thread:
try:
self.camera_loop(self.camera)
except Exception:
self.camera = Camera()
logging.error("Camera has error")
def camera_loop(self, camera):
while self.run_thread:
if self.preview_is_aktive == True:
img = camera.capture_next_preview_as_np_array()
self.newImage.emit(self._convert_picture_to_qimage(img))
if self.trigger == True:
trigger_time = datetime.now()
release_time = trigger_time + timedelta(0,Config().get_count_down_time_in_s())
self.send_to_arduino.emit(b't')
while trigger_time <= release_time:
trigger_time = datetime.now()
img = camera.capture_next_preview_as_np_array()
self.newImage.emit(self._convert_picture_to_qimage(img))
self.logger.info(f"Saving iamge to dir {self.session_dir}")
img = camera.capture_image(self.session_dir)
cov_img = self._convert_picture_to_qimage(img)
self.newImage.emit(cov_img)
self.sleep(Config().get_image_show_time_in_s())
self.logger.info("Reset trigger porperty")
self.trigger = False
time.sleep(1)
self.logger.info("deleting camera")
@Slot(bool)
def set_trigger(self, state: bool):
logging.info(f"Trigger state set to: {state}")
self.trigger = state
return True
@Slot(bool)
def set_preview_is_aktive(self, state: bool):
self.preview_is_aktive = state
return True
def _convert_picture_to_qimage(self, img):
height, width, channels = img.shape
if height > 3000 or width > 4000:
img = cv2.resize(img, (1920, 1080))
height = 1080
width = 1920
res = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
res = cv2.flip(res, 1)
#res = cv2.GaussianBlur(res,(15,15),cv2.BORDER_DEFAULT)
return QImage(res, width, height, width * channels, QImage.Format_RGB888)