Full app files (slightly tweaked from @kenzo-aspuru-takata)

.gitignore

@@ -0,0 +1,2 @@
+my_secrets.py
+__pycache__/*

app.py

@@ -1,4 +1,61 @@
 import streamlit as st
 
-x = st.slider('Select a value')
-st.write(x, 'squared is', x * x)
+
+def sidebar():
+    st.sidebar.title("Navigation")
+    selection = st.sidebar.radio(
+        "Go to",
+        [
+            "About",
+            "Request Key",
+            "Livestream",
+            "Download",
+            "GUI Control",
+            "Python Documentation",
+        ],
+    )
+    return selection
+
+
+if "current_page" not in st.session_state:
+    st.session_state.current_page = "Home"
+
+
+def main():
+    selection = sidebar()
+
+    if st.session_state.current_page != selection:
+        st.session_state.current_page = selection
+
+        st.session_state.button_clicked = False
+
+    if selection == "About":
+        st.title("AC Microscope")
+        st.write(
+            "This is a request site for credentials to use remote access to Openflexure Microscopes in the AC lab. You can either control the microscopes over python or the GUI with the help of a temporary key. You can view the live camera feed on a livestream. One person can use a microscope at once. Currently only Microscope2 is functional, but they will all be functional in the future"  # noqa: E501
+        )
+
+    elif selection == "Request Key":
+        import key_request
+
+        key_request.show()
+    elif selection == "Livestream":
+        import livestream
+
+        livestream.show()
+    elif selection == "Download":
+        import download
+
+        download.show()
+    elif selection == "GUI Control":
+        import gui_control
+
+        gui_control.show()
+    elif selection == "Python Documentation":
+        import documentation
+
+        documentation.show()
+
+
+if __name__ == "__main__":
+    main()

documentation.py

@@ -0,0 +1,89 @@
+def show():
+    import streamlit as st
+
+    st.title("AC Microscope Client Documentation")
+
+    st.subheader("Move")
+    st.write("Required parameters:")
+    st.code("move(x,y)")
+    st.write("Optional parameters:")
+    st.code("move(x,y,z,relative)")
+    st.write("Default values:")
+    st.code("z=False, relative=False")
+    st.write(
+        "The move() function moves to given coordinates x, y (and z if it is set to any integer value, if it is set to False which is the default setting, the z value wont change). If relative is True, then it will move relative to the current position instead of moving to the absolute coordinates. Coordinates arent based on screen percentage. The size of the screen is around 3600x2700."  # noqa: E501
+    )
+    st.write("")
+    st.subheader("Take image")
+    st.code("take_image()")
+    st.write(
+        "The take_image() function takes an image on the microscope camera and returns an image object"  # noqa: E501
+    )
+    st.write("")
+    st.subheader("Get position")
+    st.code("get_pos()")
+    st.write(
+        "The get_pos() returns a dictionary with x, y, and z coordinates eg. {'x':1,'y':2,'z':3}"  # noqa: E501
+    )
+    st.write("")
+    st.subheader("Focus")
+    st.write("Required parameters:")
+    st.code("focus()")
+    st.write("Optional parameters:")
+    st.code("focus(amount)")
+    st.write("Default value:")
+    st.code('amount="fast"')
+    st.write(
+        'The focus() function auto focuses by different amounts: "huge", "fast", "medium", "fine", or any integer value'  # noqa: E501
+    )
+    st.write("")
+    st.subheader("End connection")
+    st.code("end_connection()")
+    st.write(
+        "The end_connection() function ends the connection to the microscope at the end of your script. This is not required, but is reccomended to place at the end of your script."  # noqa: E501
+    )
+    st.write("")
+    st.subheader("Scan")
+    st.write("Required parameters:")
+    st.code("scan(c1,c2)")
+    st.write("Optional parameters:")
+    st.code("scan(c1,c2,ov,foc)")
+    st.write("Default values:")
+    st.code("ov=1200,foc=0")
+    st.write(
+        'The scan() function returns a list of image objects. Takes images to scan an entire area specified by two corners. you can input the corner coordinates as "x1 y1", "x2 y2" or [x1, y1], [x2, y2]. ov refers to the overlap between the images and foc refers to how much the microscope should focus between images (0 to disable)'  # noqa: E501
+    )
+    st.subheader("Scan and stitch")
+    st.write("Required parameters:")
+    st.code("scan_and_stitch(c1,c2,temp)")
+    st.write("Optional parameters:")
+    st.code("scan_and_stitch(c1,c2,temp,ov,foc,output)")
+    st.write("Default values:")
+    st.code('ov = 1200,foc = 0,output="Downloads/stitched.jpeg"')
+    st.write(
+        "The scan_and_stitch() function takes a scan with the same inputs + 2 more and outputs a stitched image. Output is the directory the stitched image will go to and temp is the temporary directory to stitch the image (make sure this is an empty directory (it will also be created automatically if it doesn't exist) the program will clear this directory) otherwise it works just like scan(). You need Openflexure Stitching installed and you need to define path_to_openflexure_stitching when instantiating your class for this to work"  # noqa: E501
+    )
+    st.write("")
+    st.subheader("Instantiating the class")
+    st.code(
+        'Microscope = MicroscopeDemo(host, port, key, microscope, path_to_openflexure_stitching) #path_to_openflexure_stitching is optional, an example for the microscope field would be "microscope2"'  # noqa: E501
+    )
+    st.write("")
+    st.subheader("Example code")
+    st.code(
+        """
+    print(microscope.get_pos())
+    microscope.take_image().show()
+    microscope.scan([2000, 2000], "-2000 -2000")
+    for i in microscope.scan("2000 2000", "-2000 -2000", ov=1500, foc=1000):
+        i.show()
+    microscope.scan_and_stitch([2000, 2000], [-2000, -2000], temp="c:/Users/-/Downloads/scanimages", output="c:/Users/-/Downloads/scanstitch.jpg") # noqa: E501
+    microscope.move(0,0)
+    microscope.focus(700)
+    microscope.move(0,1000,relative=True)
+    microscope.focus("fast")
+    microscope.move(1000,0,z=3000)
+    microscope.focus()
+    microscope.end_connection()
+    """
+    )

download.py

@@ -0,0 +1,21 @@
+def show():
+    import streamlit as st
+
+    st.title("Download")
+    st.write("You can install this program with")
+    st.code(
+        "pip install git+https://github.com... #PLACEHOLDER THIS METHOD OF INSTALLATION IS NOT READY YOU NEED TO DOWNLOAD IT MANUALLY FROM THE GITHUB AND ALSO PIP INSTALL ALL OF THE IMPORTS"  # noqa: E501
+    )
+    st.write("")
+    st.write("or use the AC github")
+    st.link_button(
+        "AC github",
+        "https://github.com/AccelerationConsortium/ac-training-lab/tree/main/src%2Fac_training_lab%2Fopenflexure",  # noqa: E501
+    )
+    st.write("")
+    st.write(
+        "You also need to install the Openflexure Stitching library if you want to stitch anything"  # noqa: E501
+    )
+    st.link_button(
+        "Openflexure Stitching", "https://gitlab.com/openflexure/openflexure-stitching"
+    )

gui_control.py

@@ -0,0 +1,92 @@
+def show():
+    # note to self you can check for empty with if statement st.image(image,
+    # caption='PIL Image', use_column_width=True)
+    import streamlit as st
+    from microscope_demo_client import MicroscopeDemo
+    from my_secrets import HIVEMQ_BROKER
+
+    port = 8883
+    microscopes = [
+        "microscope",
+        "microscope2",
+        "deltastagetransmission",
+        "deltastagereflection",
+    ]
+
+    def get_pos_button():
+        microscope = MicroscopeDemo(
+            HIVEMQ_BROKER,
+            port,
+            microscopeselection + "clientuser",
+            access_key,
+            microscopeselection,
+        )
+        # "acmicroscopedemo" is a placeholder until access keys are implemented
+        pos = microscope.get_pos()
+        st.write("x: " + str(pos["x"]))
+        st.write("y: " + str(pos["y"]))
+        st.write("z: " + str(pos["z"]))
+        microscope.end_connection()
+
+    def take_image_button():
+        microscope = MicroscopeDemo(
+            HIVEMQ_BROKER,
+            port,
+            microscopeselection + "clientuser",
+            access_key,
+            microscopeselection,
+        )
+        # "acmicroscopedemo" is a placeholder until access keys are implemented
+        st.image(
+            microscope.take_image(),
+            caption="Taken from the microscope camera",
+            use_column_width=True,
+        )
+        microscope.end_connection()
+
+    def focus_button():
+        microscope = MicroscopeDemo(
+            HIVEMQ_BROKER,
+            port,
+            microscopeselection + "clientuser",
+            access_key,
+            microscopeselection,
+        )
+        # "acmicroscopedemo" is a placeholder until access keys are implemented
+        microscope.focus(focusamount)
+        st.write("Autofocus complete")
+        microscope.end_connection()
+
+    def move_button():
+        microscope = MicroscopeDemo(
+            HIVEMQ_BROKER,
+            port,
+            microscopeselection + "clientuser",
+            access_key,
+            microscopeselection,
+        )
+        # "acmicroscopedemo" is a placeholder until access keys are implemented
+        microscope.move(xmove, ymove)
+        st.write("Move complete")
+        microscope.end_connection()
+
+    st.title("GUI control")
+
+    microscopeselection = st.selectbox(
+        "Choose a microscope:", microscopes, index=microscopes.index("microscope2")
+    )
+
+    access_key = st.text_input(label="Enter your access key here:", max_chars=1000)
+
+    st.button("Get position", on_click=get_pos_button)
+    st.write("")
+    st.button("Take image", on_click=take_image_button)
+    st.write("")
+    focusamount = st.number_input(
+        "Autofocus amount 1-5000", min_value=1, max_value=5000, step=100, value=1000
+    )
+    st.button("Focus", on_click=focus_button)
+    st.write("")
+    xmove = st.number_input("X", min_value=-20000, max_value=20000, step=250, value=0)
+    ymove = st.number_input("Y", min_value=-20000, max_value=20000, step=250, value=0)
+    st.button("Move", on_click=move_button)

key_request.py

@@ -0,0 +1,205 @@
+def show():
+    import random
+    import time
+
+    # import pymongo.mongo_client
+    import requests
+    import streamlit as st
+    from my_secrets import HIVEMQ_API_TOKEN, HIVEMQ_BASE_URL, HIVEMQ_BROKER, MONGODB_URI
+    from pymongo.mongo_client import MongoClient
+
+    # SET UP ON DATABASE you need to make a variable for the time called the
+    # same as the microscope prior to the running of the program running the
+    # function update_variable_test() will work
+    microscope = "microscope2"
+    access_time = 900
+    database_name = "openflexure-microscope"
+    collection_name = "Cluster0"
+    microscopes = [
+        "microscope",
+        "microscope2",
+        "deltastagetransmission",
+        "deltastagereflection",
+    ]
+    brokerport = "8883"
+
+    client = MongoClient(MONGODB_URI)
+    db = client[database_name]
+    collection = db[collection_name]
+
+    try:
+        client.admin.command("ping")
+        print("Pinged your deployment. You successfully connected to MongoDB!")
+    except Exception as e:
+        st.write(e)
+
+    def check_variable(variable_name):
+        try:
+
+            document = collection.find_one({"variable_name": variable_name})
+            if document:
+                return document.get("value", "Variable not found.")
+            else:
+                return "Variable not found in the collection."
+        except Exception as e:
+            return f"An error occurred: {e}"
+
+    def create_user(username, password):
+        api_url = HIVEMQ_BASE_URL + "/mqtt/credentials"
+        headers = {
+            "Authorization": f"Bearer {HIVEMQ_API_TOKEN}",
+            "Content-Type": "application/json",
+        }
+
+        new_user = {"credentials": {"username": username, "password": password}}
+
+        requests.post(api_url, json=new_user, headers=headers)
+
+    def delete_user(username):
+        headers = {
+            "Authorization": f"Bearer {HIVEMQ_API_TOKEN}",
+            "Content-Type": "application/json",
+        }
+
+        api_url = HIVEMQ_BASE_URL + "/mqtt/credentials/username/" + username
+        requests.delete(api_url, headers=headers)
+
+    def role_user(username, role):
+        headers = {
+            "Authorization": f"Bearer {HIVEMQ_API_TOKEN}",
+            "Content-Type": "application/json",
+        }
+        api_url = HIVEMQ_BASE_URL + "/user/" + username + "/roles/" + role + "/attach"
+        requests.put(api_url, headers=headers)
+
+    def update_variable(variable_name, new_value):
+        try:
+            result = collection.update_one(
+                {"variable_name": variable_name},
+                {"$set": {"value": new_value}},
+                upsert=True,
+            )
+            if result.matched_count > 0:
+                return "Variable updated successfully."
+            else:
+                return "Variable created and updated successfully."
+        except Exception as e:
+            return f"An error occurred: {e}"
+
+    def update_variable_test():
+        update_variable(microscope, random.randint(1, 10))
+
+    def check_variable_test():
+        st.write(check_variable(microscope))
+
+    def get_current_time():
+        #    api_url = "http://worldtimeapi.org/api/timezone/Etc/UTC"
+        #    try:
+        #        response = requests.get(api_url)
+        #        response.raise_for_status()
+        #        data = response.json()
+        #        return data['unixtime']
+        #    except requests.RequestException as e:
+        #        return f"Error: {e}"
+        unix_time = int(time.time())
+        return unix_time
+
+    def button():
+        st.session_state.button_clicked = True
+
+    if "button_clicked" not in st.session_state:
+        st.session_state.button_clicked = False
+    if "previous_selected_value" not in st.session_state:
+        st.session_state.previous_selected_value = microscopes[1]
+
+    st.write("Keys will last 30 minutes before being overridable")
+    st.write("Broker IP:")
+    st.code(HIVEMQ_BROKER)
+    st.write("Broker port:")
+    st.code(brokerport)
+    st.write("Usernames:")
+    st.code(
+        """
+    microscope -> microscopeclientuser
+    microscope2 -> microscope2clientuser
+    deltastagereflection -> deltastagereflectionclientuser
+    deltastagetransmission -> deltastagetransmissionclientuser
+    """
+    )
+
+    microscope = st.selectbox(
+        "Choose a microscope:", microscopes, index=microscopes.index("microscope2")
+    )
+    if microscope != st.session_state.get("previous_selected_value", microscope):
+
+        st.session_state.button_clicked = False
+
+        st.session_state["previous_selected_value"] = microscope
+
+    st.button(
+        "Request temporary access",
+        help="If somebody is using the microscope, you will need to wait",
+        on_click=button,
+    )
+
+    if st.session_state.button_clicked:
+        display_text = st.empty()
+        ctime = get_current_time()
+        var = check_variable(microscope)
+        if ctime >= var + access_time:
+
+            access_key = "Microscope" + str(random.randint(10000000, 99999999))
+            delete_user(microscope + "clientuser")
+            create_user(microscope + "clientuser", access_key)
+            if microscope == "microscope2":
+                role_user(microscope + "clientuser", "3")
+            elif microscope == "microscope":
+                role_user(microscope + "clientuser", "4")
+            elif microscope == "deltastagereflection":
+                role_user(microscope + "clientuser", "5")
+            elif microscope == "deltastagetransmission":
+                role_user(microscope + "clientuser", "6")
+
+            display_text.success(
+                "Access key: " + access_key
+            )  # change placeholder to access_key
+            update_variable(microscope, ctime)
+
+        else:
+            while True:
+                if access_time - ctime + var <= 0:
+                    display_text.success("Access key ready!")
+                    break
+                if (access_time - ctime + var) % 60 < 10:
+                    seconds = "0" + str((access_time - ctime + var) % 60)
+                else:
+                    seconds = str((access_time - ctime + var) % 60)
+                display_text.error(
+                    "Please wait "
+                    + str(
+                        int(
+                            (
+                                access_time
+                                - ctime
+                                + var
+                                - (access_time - ctime + var) % 60
+                            )
+                            / 60
+                        )
+                    )
+                    + ":"
+                    + seconds
+                )
+
+                ctime = ctime + 1
+                if ctime % 15 == 0:
+                    ctime = get_current_time() + 1
+                time.sleep(1)
+            while True:
+                time.sleep(5)
+                cutime = get_current_time()
+                var = check_variable(microscope)
+                if cutime <= var + access_time:
+                    display_text.error("The access key was taken!")
+                    break
+                time.sleep(10)

livestream.py

@@ -0,0 +1,12 @@
+def show():
+    import streamlit as st
+
+    st.title("Livestream")
+    # livestreammicroscope1 = ""
+    livestreammicroscope2 = "https://www.youtube.com/live/xbWFNAgEIDQ"
+    # livestreamdeltastagetransmission = ""
+    # livestreamdeltastagereflection = ""
+    st.write("Here are the live microscope camera views of all the microscopes")
+
+    st.write("Microscope 2:")
+    st.link_button("Microscope 2 Livestream", livestreammicroscope2)

microscope_demo_client.py

@@ -0,0 +1,182 @@
+import base64
+import io
+import json
+import os
+import shutil
+import time
+from io import BytesIO
+from queue import Queue
+
+import paho.mqtt.client as mqtt
+from PIL import Image
+
+
+class MicroscopeDemo:
+    def __init__(
+        self,
+        host,
+        port,
+        username,
+        password,
+        microscope,
+        path_to_openflexure_stitching="OPTIONAL",
+    ):
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+        self.microscope = microscope
+        self.path_to_openflexure_stitching = path_to_openflexure_stitching
+
+        self.client = mqtt.Client()
+        self.client.tls_set()
+        self.client.username_pw_set(self.username, self.password)
+
+        self.receiveq = Queue()
+
+        def on_message(client, userdata, message):
+            received = json.loads(message.payload.decode("utf-8"))
+            self.receiveq.put(received)
+            if len(json.dumps(received)) <= 300:
+                print(received)
+            else:
+                try:
+                    print(json.dumps(received)[:300] + "...")
+                except Exception as e:
+                    print(f"Command printing error (program will continue) {e}")
+
+        self.client.on_message = on_message
+
+        self.client.connect(self.host, port=self.port, keepalive=60, bind_address="")
+
+        self.client.loop_start()
+
+        self.client.subscribe(self.microscope + "/return", qos=2)
+
+    def scan_and_stitch(
+        self, c1, c2, temp, ov=1200, foc=0, output="Downloads/stitched.jpeg"
+    ):
+        """takes a scan with the same inputs + 2 more and outputs a stitched
+        image. output is the directory the stitched image will go to and temp is
+        the temporary directory to stitch the image otherwise it works just like
+        scan()"""
+        command = json.dumps(
+            {"command": "scan", "c1": c1, "c2": c2, "ov": ov, "foc": foc}
+        )
+        self.client.publish(
+            self.microscope + "/command", payload=command, qos=2, retain=False
+        )
+        while self.receiveq.empty():
+            time.sleep(0.05)
+        image = self.receiveq.get()
+        image_list = image["images"]
+        if os.path.isdir(temp):
+            shutil.rmtree(temp)
+        os.makedirs(temp)
+        for i in range(len(image_list)):
+            image_bytes = base64.b64decode(image_list[i])
+            with io.BytesIO(image_bytes) as buffer:
+                img = Image.open(buffer)
+                img.save(
+                    temp + "/" + str(i) + ".jpeg",
+                    format="JPEG",
+                    exif=img.info.get("exif"),
+                )
+        os.system(
+            "cd "
+            + self.path_to_openflexure_stitching
+            + " && python -m venv .venv && .\\.venv\\Scripts\\activate && openflexure-stitch "  # noqa: E501
+            + temp
+        )
+        # edit the cd commands so it can find the stitching program on your
+        # machine and make sure that openflexure-stitching is installed
+
+        pos = len(temp)
+        for char in ("/", "\\"):
+            index = temp.rfind(char)
+            if index != -1 and index < pos:
+                pos = index
+        result = temp[pos + 1 :] if pos < len(temp) else temp
+
+        shutil.move(temp + "/" + result + "_stitched.jpg", output)
+
+    def move(self, x, y, z=False, relative=False):
+        """moves to given coordinates x, y (and z if it is set to any integer
+        value, if it is set to False the z value wont change). If relative is
+        True, then it will move relative to the current position instead of
+        moving to the absolute coordinates"""
+        command = json.dumps(
+            {"command": "move", "x": x, "y": y, "z": z, "relative": relative}
+        )
+        self.client.publish(
+            self.microscope + "/command", payload=command, qos=2, retain=False
+        )
+        while self.receiveq.empty():
+            time.sleep(0.05)
+        return self.receiveq.get()
+
+    def scan(self, c1, c2, ov=1200, foc=0):
+        """returns a list of image objects. Takes images to scan an entire area
+        specified by two corners. you can input the corner coordinates as "x1
+        y1", "x2, y2" or [x1, y1], [x2, y2]. ov refers to the overlap between
+        the images (useful for stitching) and foc refers to how much the
+        microscope should focus between images (0 to disable)"""
+        command = json.dumps(
+            {"command": "scan", "c1": c1, "c2": c2, "ov": ov, "foc": foc}
+        )
+        self.client.publish(
+            self.microscope + "/command", payload=command, qos=2, retain=False
+        )
+        while self.receiveq.empty():
+            time.sleep(0.05)
+        image_l = self.receiveq.get()
+        image_list = image_l["images"]
+        for i in range(len(image_list)):
+            image = image_list[i]
+            image_bytes = base64.b64decode(image)
+            image_object = Image.open(BytesIO(image_bytes))
+            image_list[i] = image_object
+        return image_list
+
+    def focus(self, amount="fast"):
+        """focuses by different amounts: huge, fast, medium, fine, or any
+        integer value"""
+        command = json.dumps({"command": "focus", "amount": amount})
+        self.client.publish(
+            self.microscope + "/command", payload=command, qos=2, retain=False
+        )
+        while self.receiveq.empty():
+            time.sleep(0.05)
+        return self.receiveq.get()
+
+    def get_pos(
+        self,
+    ):
+        """returns a dictionary with x, y, and z coordinates eg.
+        {'x':1,'y':2,'z':3}"""
+        command = json.dumps({"command": "get_pos"})
+        self.client.publish(
+            self.microscope + "/command", payload=command, qos=2, retain=False
+        )
+        while self.receiveq.empty():
+            time.sleep(0.05)
+        pos = self.receiveq.get()
+        return pos["pos"]
+
+    def take_image(self):
+        """returns an image object"""
+        command = json.dumps({"command": "take_image"})
+        self.client.publish(
+            self.microscope + "/command", payload=command, qos=2, retain=False
+        )
+        while self.receiveq.empty():
+            time.sleep(0.05)
+        image = self.receiveq.get()
+        image_string = image["image"]
+        image_bytes = base64.b64decode(image_string)
+        image_object = Image.open(BytesIO(image_bytes))
+        return image_object
+
+    def end_connection(self):  # ends the connection
+        self.client.loop_stop()
+        self.client.disconnect()

requirements.txt

@@ -0,0 +1,5 @@
+paho-mqtt
+Pillow
+pymongo
+requests
+streamlit