def _set_tracking_from_scratch(self):
CameraClass = self._option_dict["camera"]["class"]
camera_kwargs = self._option_dict["camera"]["kwargs"]
ROIBuilderClass = self._option_dict["roi_builder"]["class"]
roi_builder_kwargs = self._option_dict["roi_builder"]["kwargs"]
StimulatorClass = self._option_dict["interactor"]["class"]
stimulator_kwargs = self._option_dict["interactor"]["kwargs"]
HardWareInterfaceClass = StimulatorClass.__dict__[
"_HardwareInterfaceClass"]
TrackerClass = self._option_dict["tracker"]["class"]
tracker_kwargs = self._option_dict["tracker"]["kwargs"]
ResultWriterClass = self._option_dict["result_writer"]["class"]
result_writer_kwargs = self._option_dict["result_writer"]["kwargs"]
cam = CameraClass(**camera_kwargs)
roi_builder = ROIBuilderClass(**roi_builder_kwargs)
try:
rois = roi_builder.build(cam)
except EthoscopeException as e:
cam._close()
raise e
logging.info("Initialising monitor")
cam.restart()
# the camera start time is the reference 0
ExpInfoClass = self._option_dict["experimental_info"]["class"]
exp_info_kwargs = self._option_dict["experimental_info"]["kwargs"]
self._info["experimental_info"] = ExpInfoClass(
**exp_info_kwargs).info_dic
self._info["time"] = cam.start_time
#here the hardwareconnection call the interface class without passing any argument!
hardware_connection = HardwareConnection(HardWareInterfaceClass)
self._metadata = {
"machine_id": self._info["id"],
"machine_name": self._info["name"],
"date_time":
cam.start_time, # the camera start time is the reference 0
"frame_width": cam.width,
"frame_height": cam.height,
"version": self._info["version"]["id"],
"experimental_info": str(self._info["experimental_info"]),
"selected_options": str(self._option_dict),
}
# hardware_interface is a running thread
rw = ResultWriter(self._db_credentials,
rois,
self._metadata,
take_frame_shots=True)
return (cam, rw, rois, TrackerClass, tracker_kwargs,
hardware_connection, StimulatorClass, stimulator_kwargs)
def test_stimulator(StimulatorClass,
InterfaceClass,
remove_db_file=True,
*args,
**kwargs):
tmp = tempfile.mkstemp(suffix="_ethoscope_test.db")[1]
print("Making a tmp db: " + tmp)
cam = MovieVirtualCamera(VIDEO, drop_each=15)
rb = SleepMonitorWithTargetROIBuilder()
rois = rb.build(cam)
cam.restart()
connection = HardwareConnection(InterfaceClass)
try:
# stimulators = [MockSDStimulator(connection,min_inactive_time= 10) for _ in rois ]
stimulators = [
StimulatorClass(connection, *args, **kwargs) for _ in rois
]
mon = Monitor(cam, AdaptiveBGModel, rois, stimulators=stimulators)
drawer = DefaultDrawer(draw_frames=DRAW_FRAMES)
with SQLiteResultWriter(tmp, rois) as rw:
mon.run(result_writer=rw, drawer=drawer)
# cred = {"name": "ethoscope_db",
# "user": "******",
# "password": "******"}
# with ResultWriter( cred , rois) as rw:
# mon.run(result_writer=rw, drawer=drawer)
finally:
if remove_db_file:
print("Removing temp db (" + tmp + ")")
os.remove(tmp)
else:
print("db file lives in (" + tmp + ")")
connection.stop()
def test_API(self):
random.seed(1)
cam = MovieVirtualCamera(VIDEO)
rb = SleepMonitorWithTargetROIBuilder()
rois = rb.build(cam)
hc = HardwareConnection(MockInterface)
stimulators = [MockStimulator(hc) for _ in rois]
cam.restart()
mon = Monitor(cam, AdaptiveBGModel, rois, stimulators)
drawer = DefaultDrawer(draw_frames=DRAW_FRAMES)
tmp = tempfile.mkstemp(suffix="_ethoscope_test.db")[1]
try:
print("Making a tmp db: " + tmp)
with SQLiteResultWriter(tmp, rois) as rw:
mon.run(result_writer=rw, drawer=drawer)
except:
self.fail("testAPI raised ExceptionType unexpectedly!")
finally:
hc.stop()
cam._close()
print("Removing temp db (" + tmp + ")")
os.remove(tmp)
class MockSDInterface(MockLynxMotionInterface, SleepDepriverInterface):
pass
class MockSDStimulator(SleepDepStimulator):
_HardwareInterfaceClass = MockSDInterface
tmp = tempfile.mkstemp(suffix="_ethoscope_test.db")[1]
print("Making a tmp db: " + tmp)
cam = MovieVirtualCamera(VIDEO, drop_each=15)
rb = SleepMonitorWithTargetROIBuilder()
rois = rb.build(cam)
cam.restart()
connection = HardwareConnection(MockSDInterface)
stimulators = [
MockSDStimulator(connection, min_inactive_time=10) for _ in rois
]
mon = Monitor(cam, AdaptiveBGModel, rois, stimulators=stimulators)
drawer = DefaultDrawer(draw_frames=DRAW_FRAMES)
try:
with SQLiteResultWriter(tmp, rois) as rw:
mon.run(result_writer=rw, drawer=drawer)
finally:
print("Removing temp db (" + tmp + ")")
os.remove(tmp)
connection.stop()
#INPUT_VIDEO = "videoNew_h264.mp4"
#INPUT_VIDEO = "videoCoveredtarget_h264.mp4"
OUTPUT_VIDEO = "/tmp/output_etho_motor.avi"
OUTPUT_DB = "/tmp/results_etho_motor.db"
# We use a video input file as if it was a "camera"
#cam = MovieVirtualCamera(INPUT_VIDEO)
#target_fps=20, target_resolution=(1280,960)
cam = OurPiCameraAsync()
# here, we generate ROIs automatically from the targets in the images
roi_builder = SleepMonitorWithTargetROIBuilderJanelia()
rois = roi_builder.build(cam)
# Build the stimulator
hc = HardwareConnection(JaneliaAdaptiveSleepDepriverInterface)
stimulators = [JaneliaAdaptiveSleepDepStimultor(hc) for _ in rois]
# Then, we go back to the first frame of the video
cam.restart()
# we use a drawer to show inferred position for each animal, display frames and save them as a video
drawer = DefaultDrawer(OUTPUT_VIDEO, draw_frames=False)
# We build our monitor
monitor = Monitor(cam, AdaptiveBGModel, rois, stimulators)
try:
# Now everything is ready, we run the monitor with a result writer and a drawer
with SQLiteResultWriter(OUTPUT_DB, rois) as rw:
monitor.run(rw, drawer)
def _set_tracking_from_scratch(self):
"""
"""
CameraClass = self._option_dict["camera"]["class"]
camera_args = self._option_dict["camera"]["args"]
camera_kwargs = self._option_dict["camera"]["kwargs"]
ROIBuilderClass = self._option_dict["roi_builder"]["class"]
roi_builder_kwargs = self._option_dict["roi_builder"]["kwargs"]
StimulatorClass = self._option_dict["interactor"]["class"]
stimulator_kwargs = self._option_dict["interactor"]["kwargs"]
logging.warning(StimulatorClass)
logging.warning(StimulatorClass.__dict__)
HardWareInterfaceClass = StimulatorClass.__dict__[
"_HardwareInterfaceClass"]
TrackerClass = self._option_dict["tracker"]["class"]
tracker_kwargs = self._option_dict["tracker"]["kwargs"]
ResultWriterClass = self._option_dict["result_writer"]["class"]
result_writer_kwargs = self._option_dict["result_writer"]["kwargs"]
print("camera_args")
print(camera_args)
print("camera_kwargs")
print(camera_kwargs)
cam = CameraClass(*camera_args, **camera_kwargs)
if isinstance(cam, OurPiCameraAsync):
for i, (t, frame) in cam:
cv2.imwrite(os.path.join(os.environ["HOME"], 'last_img.png'),
frame)
break
logging.info(ROIBuilderClass)
logging.info(roi_builder_kwargs)
roi_builder = ROIBuilderClass(args=(), kwargs=roi_builder_kwargs)
try:
if roi_builder.__class__.__name__ == "HighContrastTargetROIBuilder":
img, M, rois = roi_builder.build(cam)
else:
rois = roi_builder.build(cam)
M = None
except EthoscopeException as e:
cam._close()
raise e
logging.info(f"PID {os.getpid()}: Initialising monitor")
cam.restart()
# the camera start time is the reference 0
ExpInfoClass = self._option_dict["experimental_info"]["class"]
exp_info_kwargs = self._option_dict["experimental_info"]["kwargs"]
self._info["experimental_info"] = ExpInfoClass(
**exp_info_kwargs).info_dic
self._info["time"] = cam.start_time
#here the hardwareconnection call the interface class without passing any argument!
hardware_connection = HardwareConnection(HardWareInterfaceClass)
#creates a unique tracking id to label this tracking run
self._info["experimental_info"]["run_id"] = secrets.token_hex(8)
if self._info["experimental_info"]["sensor"]:
#if is URL:
sensor = EthoscopeSensor(self._info["experimental_info"]["sensor"])
logging.info("Using sensor with URL %s" %
self._info["experimental_info"]["sensor"])
else:
sensor = None
logging.info("Generating metadata of this run")
logging.info(self._info)
self._metadata = {
"machine_id": self._info["id"],
"machine_name": self._info["name"],
"date_time":
cam.start_time, # the camera start time is the reference 0
"frame_width": cam.width,
"frame_height": cam.height,
"version": self._info["version"]["id"],
"experimental_info": str(self._info["experimental_info"]),
"selected_options": str(self._option_dict),
}
logging.warning("Detected camera start time is %d", cam.start_time)
# hardware_interface is a running thread
rw = ResultWriterClass(self._db_credentials,
rois,
metadata=self._metadata,
sensor=sensor,
**result_writer_kwargs)
return (cam, rw, rois, M, TrackerClass, tracker_kwargs,
hardware_connection, StimulatorClass, stimulator_kwargs)
def _set_tracking_from_scratch(self):
"""
"""
CameraClass = self._option_dict["camera"]["class"]
camera_kwargs = self._option_dict["camera"]["kwargs"]
ROIBuilderClass = self._option_dict["roi_builder"]["class"]
roi_builder_kwargs = self._option_dict["roi_builder"]["kwargs"]
StimulatorClass = self._option_dict["interactor"]["class"]
stimulator_kwargs = self._option_dict["interactor"]["kwargs"]
HardWareInterfaceClass = StimulatorClass.__dict__[
"_HardwareInterfaceClass"]
TrackerClass = self._option_dict["tracker"]["class"]
tracker_kwargs = self._option_dict["tracker"]["kwargs"]
ResultWriterClass = self._option_dict["result_writer"]["class"]
result_writer_kwargs = self._option_dict["result_writer"]["kwargs"]
cam = CameraClass(**camera_kwargs)
roi_builder = ROIBuilderClass(**roi_builder_kwargs)
try:
reference_points, rois = roi_builder.build(cam)
except EthoscopeException as e:
cam._close()
raise e
logging.info("Initialising monitor")
cam.restart()
# the camera start time is the reference 0
ExpInfoClass = self._option_dict["experimental_info"]["class"]
exp_info_kwargs = self._option_dict["experimental_info"]["kwargs"]
self._info["experimental_info"] = ExpInfoClass(
**exp_info_kwargs).info_dic
self._info["time"] = cam.start_time
#here the hardwareconnection call the interface class without passing any argument!
hardware_connection = HardwareConnection(HardWareInterfaceClass)
#creates a unique tracking id to label this tracking run
self._info["experimental_info"]["run_id"] = secrets.token_hex(8)
if self._info["experimental_info"]["sensor"]:
#if is URL:
sensor = EthoscopeSensor(self._info["experimental_info"]["sensor"])
logging.info("Using sensor with URL %s" %
self._info["experimental_info"]["sensor"])
else:
sensor = None
if "append" in self._info["experimental_info"]:
append_to_db = self._info["experimental_info"]["append"]
logging.info([
"Recreating a new database",
"Appending tracking data to the existing database"
][append_to_db])
else:
append_to_db = False
#this will be saved in the metadata table
self._metadata = {
"machine_id": self._info["id"],
"machine_name": self._info["name"],
"date_time":
cam.start_time, # the camera start time is the reference 0
"frame_width": cam.width,
"frame_height": cam.height,
"version": self._info["version"]["id"],
"experimental_info": str(self._info["experimental_info"]),
"selected_options": str(self._option_dict),
"hardware_info": str(self.hw_info),
"reference_points": str([(p[0], p[1]) for p in reference_points])
}
# hardware_interface is a running thread
rw = ResultWriter(
self._db_credentials,
rois,
self._metadata,
take_frame_shots=True,
erase_old_db=(not append_to_db),
sensor=sensor,
)
return (cam, rw, rois, reference_points, TrackerClass, tracker_kwargs,
hardware_connection, StimulatorClass, stimulator_kwargs)
return HasInteractedVariable(True), dic
return HasInteractedVariable(False), {}
if __name__ == "__main__":
import numpy as np
from ethoscope.trackers.adaptive_bg_tracker import AdaptiveBGModel
from ethoscope.core.roi import ROI
from ethoscope.hardware.interfaces.interfaces import HardwareConnection
def never_moving():
return False
hc = HardwareConnection(RobustSleepDepriver._HardwareInterfaceClass,
do_warm_up=False)
sd = RobustSleepDepriver(
hc,
velocity_correction_coef=0.01,
min_inactive_time=10, # s
pulse_duration=1000, #ms
date_range="")
sd._has_moved = never_moving
sd._t0 = 0
roi = ROI(polygon=np.array([[0, 10], [10, 10], [10, 0], [0, 0]]), idx=1)
tracker = AdaptiveBGModel(roi=roi)
tracker._last_time_point = 30000 #ms
sd.bind_tracker(tracker)