diff --git a/scripts/mqtt_pump_focus_image_v2.py b/scripts/mqtt_pump_focus_image_v2.py new file mode 100644 index 0000000..4b51328 --- /dev/null +++ b/scripts/mqtt_pump_focus_image_v2.py @@ -0,0 +1,389 @@ +import paho.mqtt.client as mqtt +from picamera import PiCamera +from datetime import datetime, timedelta +from adafruit_motor import stepper +from adafruit_motorkit import MotorKit +from time import sleep +import json + +import os +import subprocess + +from skimage.util import img_as_ubyte + +from morphocut import Call +from morphocut.contrib.ecotaxa import EcotaxaWriter +from morphocut.contrib.zooprocess import CalculateZooProcessFeatures +from morphocut.core import Pipeline +from morphocut.file import Find +from morphocut.image import ( + ExtractROI, + FindRegions, + ImageReader, + ImageWriter, + RescaleIntensity, + RGB2Gray, +) + +from morphocut.stat import RunningMedian +from morphocut.str import Format +from morphocut.stream import TQDM, Enumerate, FilterVariables + +from skimage.feature import canny +from skimage.color import rgb2gray, label2rgb +from skimage.morphology import disk +from skimage.morphology import erosion, dilation, closing +from skimage.measure import label, regionprops +import cv2, shutil + +import smbus +#fan +bus = smbus.SMBus(1) +################################################################################ +kit = MotorKit() +pump_stepper = kit.stepper1 +pump_stepper.release() +focus_stepper = kit.stepper2 +focus_stepper.release() + +################################################################################ + +camera = PiCamera() +camera.resolution = (3280, 2464) +camera.iso = 60 +camera.shutter_speed = 500 +camera.exposure_mode = 'fixedfps' + +################################################################################ +message = '' +topic = '' +count='' + +################################################################################ + +def on_connect(client, userdata, flags, rc): + print("Connected! - " + str(rc)) + client.subscribe("actuator/#") + rgb(0,255,0) +def on_subscribe(client, obj, mid, granted_qos): + print("Subscribed! - "+str(mid)+" "+str(granted_qos)) + +def on_message(client, userdata, msg): + print(msg.topic+" "+str(msg.qos)+" "+str(msg.payload)) + global message + global topic + global count + message=str(msg.payload.decode()) + topic=msg.topic.split("/")[1] + count=0 + +def on_log(client, obj, level, string): + print(string) + +def rgb(R,G,B): + bus.write_byte_data(0x0d, 0x00, 0) + bus.write_byte_data(0x0d, 0x01, R) + bus.write_byte_data(0x0d, 0x02, G) + bus.write_byte_data(0x0d, 0x03, B) + + bus.write_byte_data(0x0d, 0x00, 1) + bus.write_byte_data(0x0d, 0x01, R) + bus.write_byte_data(0x0d, 0x02, G) + bus.write_byte_data(0x0d, 0x03, B) + + bus.write_byte_data(0x0d, 0x00, 2) + bus.write_byte_data(0x0d, 0x01, R) + bus.write_byte_data(0x0d, 0x02, G) + bus.write_byte_data(0x0d, 0x03, B) + cmd="i2cdetect -y 1" + subprocess.Popen(cmd.split(),stdout=subprocess.PIPE) + +################################################################################ +client = mqtt.Client() +client.connect("127.0.0.1",1883,60) +client.on_connect = on_connect +client.on_subscribe = on_subscribe +client.on_message = on_message +client.on_log = on_log +client.loop_start() + + +local_metadata = { + "process_datetime": datetime.now(), + "acq_camera_resolution" : camera.resolution, + "acq_camera_iso" : camera.iso, + "acq_camera_shutter_speed" : camera.shutter_speed +} + +config_txt = open('/home/pi/PlanktonScope/config.txt','r') +node_red_metadata = json.loads(config_txt.read()) + +global_metadata = {**local_metadata, **node_red_metadata} + +archive_fn = os.path.join("/home/pi/PlanktonScope/","export", "ecotaxa_export.zip") +# Define processing pipeline +with Pipeline() as p: + # Recursively find .jpg files in import_path. + # Sort to get consective frames. + abs_path = Find("/home/pi/PlanktonScope/tmp", [".jpg"], sort=True, verbose=True) + + # Extract name from abs_path + name = Call(lambda p: os.path.splitext(os.path.basename(p))[0], abs_path) + + Call(rgb, 0,255,0) + # Read image + img = ImageReader(abs_path) + + # Show progress bar for frames + #TQDM(Format("Frame {name}", name=name)) + + # Apply running median to approximate the background image + flat_field = RunningMedian(img, 5) + + # Correct image + img = img / flat_field + + # Rescale intensities and convert to uint8 to speed up calculations + img = RescaleIntensity(img, in_range=(0, 1.1), dtype="uint8") + +# frame_fn = Format(os.path.join("/home/pi/PlanktonScope/tmp","CLEAN", "{name}.jpg"), name=name) + +# ImageWriter(frame_fn, img) + + # Convert image to uint8 gray + img_gray = RGB2Gray(img) + + # ? + img_gray = Call(img_as_ubyte, img_gray) + + #Canny edge detection + img_canny = Call(cv2.Canny, img_gray, 50,100) + + #Dilate + kernel = Call(cv2.getStructuringElement, cv2.MORPH_ELLIPSE, (15, 15)) + img_dilate = Call(cv2.dilate, img_canny, kernel, iterations=2) + + #Close + kernel = Call(cv2.getStructuringElement, cv2.MORPH_ELLIPSE, (5, 5)) + img_close = Call(cv2.morphologyEx, img_dilate, cv2.MORPH_CLOSE, kernel, iterations=1) + + #Erode + kernel = Call(cv2.getStructuringElement, cv2.MORPH_ELLIPSE, (15, 15)) + mask = Call(cv2.erode, img_close, kernel, iterations=2) + + # Find objects + regionprops = FindRegions( + mask, img_gray, min_area=1000, padding=10, warn_empty=name + ) + + Call(rgb, 255,0,255) + # For an object, extract a vignette/ROI from the image + roi_orig = ExtractROI(img, regionprops, bg_color=255) + + # Generate an object identifier + i = Enumerate() + #Call(print,i) + + object_id = Format("{name}_{i:d}", name=name, i=i) + #Call(print,object_id) + + object_fn = Format(os.path.join("/home/pi/PlanktonScope/","OBJECTS", "{name}.jpg"), name=object_id) + + ImageWriter(object_fn, roi_orig) + + # Calculate features. The calculated features are added to the global_metadata. + # Returns a Variable representing a dict for every object in the stream. + meta = CalculateZooProcessFeatures( + regionprops, prefix="object_", meta=global_metadata + ) + +# json_meta = Call(json.dumps,meta, sort_keys=True, default=str) + +# Call(client.publish, "receiver/segmentation/metric", json_meta) + + # Add object_id to the metadata dictionary + meta["object_id"] = object_id + + # Generate object filenames + orig_fn = Format("{object_id}.jpg", object_id=object_id) + + # Write objects to an EcoTaxa archive: + # roi image in original color, roi image in grayscale, metadata associated with each object + EcotaxaWriter(archive_fn, (orig_fn, roi_orig), meta) + + # Progress bar for objects + TQDM(Format("Object {object_id}", object_id=object_id)) + +# Call(client.publish, "receiver/segmentation/object_id", object_id) + + +camera.start_preview(fullscreen=False, window = (160, 0, 640, 480)) +################################################################################ +while True: + +################################################################################ + if (topic=="pump"): + rgb(0,0,255) + direction=message.split(" ")[0] + delay=float(message.split(" ")[1]) + nb_step=int(message.split(" ")[2]) + + client.publish("receiver/pump", "Start"); + + + while True: + + if direction == "BACKWARD": + direction=stepper.BACKWARD + if direction == "FORWARD": + direction=stepper.FORWARD + count+=1 +# print(count,nb_step) + pump_stepper.onestep(direction=direction, style=stepper.DOUBLE) + sleep(delay) + + if topic!="pump": + pump_stepper.release() + print("The pump has been interrompted.") + client.publish("receiver/pump", "Interrompted"); + rgb(0,255,0) + break + + if count>nb_step: + pump_stepper.release() + print("The pumping is done.") + topic="wait" + client.publish("receiver/pump", "Done"); + rgb(0,255,0) + break + +################################################################################ + + elif (topic=="focus"): + + rgb(255,255,0) + direction=message.split(" ")[0] + nb_step=int(message.split(" ")[1]) + client.publish("receiver/focus", "Start"); + + + while True: + + if direction == "FORWARD": + direction=stepper.FORWARD + if direction == "BACKWARD": + direction=stepper.BACKWARD + count+=1 +# print(count,nb_step) + focus_stepper.onestep(direction=direction, style=stepper.MICROSTEP) + + if topic!="focus": + focus_stepper.release() + print("The stage has been interrompted.") + client.publish("receiver/focus", "Interrompted"); + rgb(0,255,0) + break + + if count>nb_step: + focus_stepper.release() + print("The focusing is done.") + topic="wait" + client.publish("receiver/focus", "Done"); + rgb(0,255,0) + break + +################################################################################ + + elif (topic=="image"): + + + sleep_before=int(message.split(" ")[0]) + + nb_step=int(message.split(" ")[1]) + + path=str(message.split(" ")[2]) + + nb_frame=int(message.split(" ")[3]) + + sleep_during=int(message.split(" ")[4]) + + #sleep a duration before to start + sleep(sleep_before) + + client.publish("receiver/image", "Start"); + + #flushing before to begin + + rgb(0,0,255) + for i in range(nb_step): + pump_stepper.onestep(direction=stepper.FORWARD, style=stepper.DOUBLE) + sleep(0.01) + rgb(0,255,0) + + while True: + + count+=1 +# print(count,nb_frame) + + filename = os.path.join("/home/pi/PlanktonScope/tmp",datetime.now().strftime("%M_%S_%f")+".jpg") + + rgb(0,255,255) + camera.capture(filename) + rgb(0,255,0) + + client.publish("receiver/image", datetime.now().strftime("%M_%S_%f")+".jpg has been imaged."); + + rgb(0,0,255) + for i in range(10): + pump_stepper.onestep(direction=stepper.FORWARD, style=stepper.DOUBLE) + sleep(0.01) + sleep(0.5) + rgb(0,255,0) + + if(count>nb_frame): + +# camera.stop_preview() + + client.publish("receiver/image", "Completed"); + # Meta data that is added to every object + + + + client.publish("receiver/segmentation", "Start"); + # Define processing pipeline + + p.run() + + #remove directory + #shutil.rmtree(import_path) + + client.publish("receiver/segmentation", "Completed"); + + command = os.popen("rm -rf /home/pi/PlanktonScope/tmp/*.jpg") + + rgb(255,255,255) + sleep(sleep_during) + rgb(0,255,0) + + + rgb(0,0,255) + for i in range(nb_step): + pump_stepper.onestep(direction=stepper.FORWARD, style=stepper.DOUBLE) + sleep(0.01) + rgb(0,255,0) + + count=0 + + if topic!="image": + pump_stepper.release() + print("The imaging has been interrompted.") + client.publish("receiver/image", "Interrompted"); + rgb(0,255,0) + count=0 + break + + else: +# print("Waiting") + sleep(1) + +