def scan_complete(self):
self._logger.debug("Scan complete writing pointcloud files with %i points." % (self.point_cloud.get_size(),))
self.point_cloud.saveAsFile(self._prefix)
self.settings.saveAsFile(self._prefix)
message = FSUtil.new_message()
message['type'] = FSEvents.ON_INFO_MESSAGE
message['data']['message'] = "SAVING_POINT_CLOUD"
message['data']['scan_id'] = self._prefix
message['data']['level'] = "info"
self.eventManager.publish(FSEvents.ON_SOCKET_BROADCAST,message)
FSUtil.delete_image_folders(self._prefix)
self.reset_scanner_state()
event = FSEvent()
event.command = '_COMPLETE'
#TODO: generate MESH Here if option is selected in scan settings!
#self.create_mesh(self._prefix)
self.eventManager.publish(FSEvents.COMMAND,event)
message = FSUtil.new_message()
message['type'] = FSEvents.ON_INFO_MESSAGE
message['data']['message'] = "SCAN_COMPLETE"
message['data']['scan_id'] = self._prefix
message['data']['level'] = "success"
self.eventManager.publish(FSEvents.ON_SOCKET_BROADCAST,message)
def notify_if_is_not_calibrated(self):
try:
self._logger.debug(self.config.file.calibration.camera_matrix)
is_calibrated = self.scanner_is_calibrated()
self._logger.debug(
"FabScan is calibrated: {0}".format(is_calibrated))
if not is_calibrated:
message = {
"message": "SCANNER_NOT_CALIBRATED",
"level": "warn"
}
self._logger.debug("Clients informaed")
event = FSEvent()
event.command = "STOP"
self.eventmanager.publish(FSEvents.COMMAND, event)
self.eventmanager.broadcast_client_message(
FSEvents.ON_INFO_MESSAGE, message)
return
except Exception as e:
self._logger.exception(e)
def scan_complete(self):
self._logger.debug(
"Scan complete writing pointcloud files with %i points." %
(self.point_cloud.get_size(), ))
self.point_cloud.saveAsFile(self._prefix)
self.settings.saveAsFile(self._prefix)
message = FSUtil.new_message()
message['type'] = FSEvents.ON_INFO_MESSAGE
message['data']['message'] = "SAVING_POINT_CLOUD"
message['data']['scan_id'] = self._prefix
message['data']['level'] = "info"
self.eventManager.publish(FSEvents.ON_SOCKET_BROADCAST, message)
FSUtil.delete_image_folders(self._prefix)
self.reset_scanner_state()
event = FSEvent()
event.command = '_COMPLETE'
#TODO: generate MESH Here if option is selected in scan settings!
#self.create_mesh(self._prefix)
self.eventManager.publish(FSEvents.COMMAND, event)
message = FSUtil.new_message()
message['type'] = FSEvents.ON_INFO_MESSAGE
message['data']['message'] = "SCAN_COMPLETE"
message['data']['scan_id'] = self._prefix
message['data']['level'] = "success"
self.eventManager.publish(FSEvents.ON_SOCKET_BROADCAST, message)
def scan_complete(self):
self._logger.debug("Scan complete writing pointcloud files with %i points." % (self.point_cloud.get_size(),))
self.point_cloud.saveAsFile(self._prefix)
self.settings.saveAsFile(self._prefix)
message = {
"message": "SAVING_POINT_CLOUD",
"scan_id": self._prefix,
"level": "info"
}
self.eventManager.broadcast_client_message(FSEvents.ON_INFO_MESSAGE, message)
FSUtil.delete_image_folders(self._prefix)
self.reset_scanner_state()
event = FSEvent()
event.command = 'COMPLETE'
self.eventManager.publish(FSEvents.COMMAND,event)
message = {
"message": "SCAN_COMPLETE",
"scan_id": self._prefix,
"level": "success"
}
self.eventManager.broadcast_client_message(FSEvents.ON_INFO_MESSAGE, message)
self.hardwareController.camera.device.stopStream()
def start_scan(self):
self.settings_mode_off()
self._logger.info("Scan started")
self._stop_scan = False
if self._worker_pool is None or not self._worker_pool.is_alive():
self._worker_pool = FSImageWorkerPool.start(scanprocessor=self.actor_ref)
self._worker_pool.tell(
{FSEvents.COMMAND: FSSWorkerPoolCommand.CREATE, 'NUMBER_OF_WORKERS': self.config.file.process_numbers}
)
self.hardwareController.turntable.enable_motors()
for i in range(int(self.config.file.laser.numbers)):
self.hardwareController.laser.off(0)
self.hardwareController.laser.off(1)
self._resolution = int(self.settings.file.resolution)
self._is_color_scan = bool(self.settings.file.color)
self._number_of_pictures = int(self.config.file.turntable.steps // self.settings.file.resolution)
self.current_position = 0
self._starttime = self.get_time_stamp()
# TODO: rename prefix to scan_id
self._prefix = datetime.fromtimestamp(time.time()).strftime('%Y%m%d-%H%M%S')
# initialize pointcloud actors...
self.point_clouds = []
#self.point_clouds = [FSPointCloud(config=self.config, color=self._is_color_scan) for _ in range(self.config.file.laser.numbers)]
for laser_index in range(self.config.file.laser.numbers):
self.point_clouds.append(FSPointCloud(config=self.config, color=self._is_color_scan, filename=self._prefix, postfix=laser_index, binary=False))
if self.config.file.laser.numbers > 1:
self.both_cloud = FSPointCloud(config=self.config, color=self._is_color_scan, filename=self._prefix, postfix='both', binary=False)
if not (self.config.file.calibration.laser_planes[0]['normal'] == []) and self.actor_ref.is_alive():
if self._is_color_scan:
self._total = (self._number_of_pictures * self.config.file.laser.numbers) + self._number_of_pictures
self.actor_ref.tell({FSEvents.COMMAND: FSScanProcessorCommand._SCAN_NEXT_TEXTURE_POSITION})
else:
self._total = self._number_of_pictures * self.config.file.laser.numbers
self.actor_ref.tell({FSEvents.COMMAND: FSScanProcessorCommand._SCAN_NEXT_OBJECT_POSITION})
else:
self._logger.debug("FabScan is not calibrated scan canceled")
message = {
"message": "SCANNER_NOT_CALIBRATED",
"level": "warn"
}
self.eventmanager.broadcast_client_message(FSEvents.ON_INFO_MESSAGE, message)
event = FSEvent()
event.command = 'STOP'
self.eventmanager.publish(FSEvents.COMMAND, event)
def start(self):
tools = FSSystem()
tools.delete_folder(self.config.folders.scans + 'calibration')
self._hardwarecontroller.turntable.enable_motors()
self._hardwarecontroller.led.on(self.calibration_brightness[0],
self.calibration_brightness[1],
self.calibration_brightness[2])
#self.settings.camera.contrast = 30
#self.settings.camera.saturation = 20
#self.settings.camera.brightness = 50
self.reset_calibration_values()
self.settings.threshold = 25
self._starttime = self.get_time_stamp()
message = {"message": "START_CALIBRATION", "level": "info"}
self._eventmanager.broadcast_client_message(FSEvents.ON_INFO_MESSAGE,
message)
try:
self._hardwarecontroller.start_camera_stream(mode="calibration")
self._do_calibration(self._capture_camera_calibration,
self._calculate_camera_calibration)
self._do_calibration(self._capture_scanner_calibration,
self._calculate_scanner_calibration)
self._hardwarecontroller.led.off()
self._hardwarecontroller.turntable.disable_motors()
if self._stop:
self._logger.debug("Calibration canceled...")
# send information to client that calibration is finished
message = {"message": "STOPPED_CALIBRATION", "level": "info"}
self._eventmanager.broadcast_client_message(
FSEvents.ON_INFO_MESSAGE, message)
self._hardwarecontroller.stop_camera_stream()
self._stop = False
else:
event = FSEvent()
event.command = 'CALIBRATION_COMPLETE'
self._eventmanager.publish(FSEvents.COMMAND, event)
# send information to client that calibration is finished
message = {"message": "FINISHED_CALIBRATION", "level": "info"}
self.config.save()
self._eventmanager.broadcast_client_message(
FSEvents.ON_INFO_MESSAGE, message)
self._hardwarecontroller.stop_camera_stream()
self.reset_calibration_values()
return
except StandardError as e:
self._logger.error(e)
def start_scan(self):
self.settings_mode_off()
self._logger.info("Scan started")
self._stop_scan = False
if self._worker_pool is None:
self._worker_pool = FSImageWorkerPool(self.image_task_q,
self.event_q)
self.hardwareController.turntable.enable_motors()
self.hardwareController.start_camera_stream(mode="default")
time.sleep(1.5)
self._resolution = int(self.settings.resolution)
self._laser_positions = int(self.settings.laser_positions)
self._is_color_scan = bool(self.settings.color)
self._number_of_pictures = old_div(self.config.turntable.steps,
int(self.settings.resolution))
self.current_position = 0
self._starttime = self.get_time_stamp()
# TODO: rename prefix to scan_id
self._prefix = datetime.fromtimestamp(
time.time()).strftime('%Y%m%d-%H%M%S')
self.point_cloud = FSPointCloud(color=self._is_color_scan)
if not (self.config.calibration.laser_planes[0]['normal']
== []) and self.actor_ref.is_alive():
if self._is_color_scan:
self._total = self._number_of_pictures * 2 * self.config.laser.numbers
self.actor_ref.tell({
FSEvents.COMMAND:
FSScanProcessorCommand._SCAN_NEXT_TEXTURE_POSITION
})
else:
self._total = self._number_of_pictures * self.config.laser.numbers
self.actor_ref.tell({
FSEvents.COMMAND:
FSScanProcessorCommand._SCAN_NEXT_OBJECT_POSITION
})
else:
self._logger.debug("FabScan is not calibrated scan canceled")
message = {"message": "SCANNER_NOT_CALIBRATED", "level": "warn"}
self.eventmanager.broadcast_client_message(
FSEvents.ON_INFO_MESSAGE, message)
event = FSEvent()
event.command = 'STOP'
self.eventmanager.publish(FSEvents.COMMAND, event)
def start(self):
self._hardwarecontroller.turntable.enable_motors()
self._hardwarecontroller.led.on(self.calibration_brightness[0], self.calibration_brightness[1], self.calibration_brightness[2])
self.settings.camera.contrast = 30
#self.settings.camera.saturation = 20
self.settings.camera.brightness = 50
self.reset_calibration_values()
self.settings.threshold = 25
message = {
"message": "START_CALIBRATION",
"level": "info"
}
self._eventmanager.broadcast_client_message(FSEvents.ON_INFO_MESSAGE, message)
self._hardwarecontroller.camera.device.startStream()
self._do_calibration(self._capture_camera_calibration, self._calculate_camera_calibration)
self._do_calibration(self._capture_scanner_calibration, self._calculate_scanner_calibration)
self._hardwarecontroller.led.off()
self._hardwarecontroller.turntable.disable_motors()
if self._stop:
self._logger.debug("Calibration canceled...")
# send information to client that calibration is finished
message = {
"message": "STOPPED_CALIBRATION",
"level": "info"
}
self._eventmanager.broadcast_client_message(FSEvents.ON_INFO_MESSAGE, message)
self._stop = False
else:
event = FSEvent()
event.command = 'CALIBRATION_COMPLETE'
self._eventmanager.publish(FSEvents.COMMAND, event)
# send information to client that calibration is finished
message = {
"message": "FINISHED_CALIBRATION",
"level": "info"
}
self.config.save()
self._eventmanager.broadcast_client_message(FSEvents.ON_INFO_MESSAGE, message)
self.current_position = 0
def init_object_scan(self):
self._logger.debug("Started object scan initialisation")
self.current_position = 0
self._laser_positions = self.settings.laser_positions
self.hardwareController.led.on(self.settings.led.red,
self.settings.led.green,
self.settings.led.blue)
self.hardwareController.laser.on()
self.settings.camera.brightness = self._scan_brightness
self.settings.camera.contrast = self._scan_contrast
self.settings.camera.saturation = self._scan_saturation
# TODO: solve this timing issue!
# Workaround for Logitech webcam. We have to wait a loooong time until the logitech cam is ready...
#time.sleep(3)
self.hardwareController.camera.device.objectExposure()
self.hardwareController.camera.device.flushStream()
time.sleep(2)
self._laser_angle = self.image_processor.calculate_laser_angle(
self.hardwareController.camera.device.getFrame())
if self._laser_angle == None:
event = FSEvent()
event.command = '_LASER_DETECTION_FAILED'
self.eventManager.publish(FSEvents.COMMAND, event)
self.on_laser_detection_failed()
self._logger.debug("Send laser detection failure event")
else:
message = FSUtil.new_message()
message['type'] = FSEvents.ON_INFO_MESSAGE
message['data']['message'] = "SCANNING_OBJECT"
message['data']['level'] = "info"
self.eventManager.publish(FSEvents.ON_SOCKET_BROADCAST, message)
self._logger.debug("Detected Laser Angle at: %f deg" %
(self._laser_angle, ))
self._worker_pool.create(self.config.process_numbers)
def scan_complete(self):
self._worker_pool.tell(
{FSEvents.COMMAND: FSSWorkerPoolCommand.KILL}
)
end_time = self.get_time_stamp()
duration = int((end_time - self._starttime)//1000)
self._logger.debug("Time Total: %i sec." % (duration,))
if len(self.point_clouds) == self.config.file.laser.numbers:
self._logger.info("Scan complete writing pointcloud.")
self._logger.debug('Number of PointClouds (for each laser one) : ' +str(len(self.point_clouds)))
self.finishFiles()
settings_filename = self.config.file.folders.scans+self._prefix+"/"+self._prefix+".fab"
self.settings.save_json(settings_filename)
#if bool(self.config.file.keep_raw_images):
# self.utils.zipdir(str(self._prefix))
self.utils.delete_image_folders(self._prefix)
self.reset_scanner_state()
event = FSEvent()
event.command = 'COMPLETE'
self.eventmanager.publish(FSEvents.COMMAND, event)
message = {
"message": "SCAN_COMPLETE",
"scan_id": self._prefix,
"level": "success"
}
self.eventmanager.broadcast_client_message(FSEvents.ON_INFO_MESSAGE, message)
self.hardwareController.stop_camera_stream()
def scan_complete(self):
end_time = self.get_time_stamp()
duration = old_div(int(end_time - self._starttime), 1000)
self._logger.debug("Time Total: %i sec." % (duration, ))
self._starttime = 0
self._logger.info(
"Scan complete writing pointcloud files with %i points." %
(self.point_cloud.get_size(), ))
self.point_cloud.saveAsFile(self._prefix)
settings_filename = self.config.folders.scans + self._prefix + "/" + self._prefix + ".fab"
self.settings.saveAsFile(settings_filename)
message = {
"message": "SAVING_POINT_CLOUD",
"scan_id": self._prefix,
"level": "info"
}
self.eventmanager.broadcast_client_message(FSEvents.ON_INFO_MESSAGE,
message)
self.utils.delete_image_folders(self._prefix)
self.reset_scanner_state()
event = FSEvent()
event.command = 'COMPLETE'
self.eventmanager.publish(FSEvents.COMMAND, event)
message = {
"message": "SCAN_COMPLETE",
"scan_id": self._prefix,
"level": "success"
}
self.eventmanager.broadcast_client_message(FSEvents.ON_INFO_MESSAGE,
message)
self.hardwareController.stop_camera_stream()
def init_object_scan(self):
self._logger.debug("Started object scan initialisation")
self.current_position = 0
self._laser_positions = self.settings.laser_positions
self.hardwareController.led.on(self.settings.led.red,self.settings.led.green,self.settings.led.blue)
self.hardwareController.laser.on()
self.settings.camera.brightness = self._scan_brightness
self.settings.camera.contrast = self._scan_contrast
self.settings.camera.saturation = self._scan_saturation
# TODO: solve this timing issue!
# Workaround for Logitech webcam. We have to wait a loooong time until the logitech cam is ready...
#time.sleep(3)
self.hardwareController.camera.device.objectExposure()
self.hardwareController.camera.device.flushStream()
time.sleep(2)
self._laser_angle = self.image_processor.calculate_laser_angle(self.hardwareController.camera.device.getFrame())
if self._laser_angle == None:
event = FSEvent()
event.command = '_LASER_DETECTION_FAILED'
self.eventManager.publish(FSEvents.COMMAND,event)
self.on_laser_detection_failed()
self._logger.debug("Send laser detection failure event")
else:
message = FSUtil.new_message()
message['type'] = FSEvents.ON_INFO_MESSAGE
message['data']['message'] = "SCANNING_OBJECT"
message['data']['level'] = "info"
self.eventManager.publish(FSEvents.ON_SOCKET_BROADCAST,message)
self._logger.debug("Detected Laser Angle at: %f deg" %(self._laser_angle, ))
self._worker_pool.create(self.config.process_numbers)
def start(self):
#self._hardwarecontroller.stop_camera_stream()
tools = FSSystem()
#self._hardwarecontroller.stop_camera_stream()
tools.delete_folder(self.config.file.folders.scans + 'calibration')
self._hardwarecontroller.turntable.enable_motors()
time.sleep(0.2)
if self.config.file.laser.interleaved == "False":
self._logger.debug("Turning Leds on in non interleaved mode.")
self._hardwarecontroller.led.on(self.calibration_brightness[0],
self.calibration_brightness[1],
self.calibration_brightness[2])
self.reset_calibration_values()
self.settings.threshold = 25
self._starttime = self.get_time_stamp()
message = {"message": "START_CALIBRATION", "level": "info"}
self._eventmanager.broadcast_client_message(FSEvents.ON_INFO_MESSAGE,
message)
try:
self._hardwarecontroller.start_camera_stream(mode="calibration")
self._do_calibration(self._capture_camera_calibration,
self._calculate_camera_calibration)
self._do_calibration(self._capture_scanner_calibration,
self._calculate_scanner_calibration)
if self.config.file.laser.interleaved == "False":
self._hardwarecontroller.led.off()
self._hardwarecontroller.turntable.disable_motors()
if self._stop:
self._logger.debug("Calibration canceled...")
# send information to client that calibration is finished
message = {"message": "STOPPED_CALIBRATION", "level": "info"}
self._eventmanager.broadcast_client_message(
FSEvents.ON_INFO_MESSAGE, message)
self._stop = False
else:
event = FSEvent()
event.command = 'CALIBRATION_COMPLETE'
self._eventmanager.publish(FSEvents.COMMAND, event)
# send information to client that calibration is finished
message = {"message": "FINISHED_CALIBRATION", "level": "info"}
self.config.save_json()
self._eventmanager.broadcast_client_message(
FSEvents.ON_INFO_MESSAGE, message)
self._hardwarecontroller.stop_camera_stream()
self._hardwarecontroller.led.off()
self._hardwarecontroller.turntable.disable_motors()
self.reset_calibration_values()
return
except Exception as e:
self._logger.exception(e)
message = {
"message": "SCANNER_CALIBRATION_FAILED",
"level": "warn"
}
self._eventmanager.broadcast_client_message(
FSEvents.ON_INFO_MESSAGE, message)
