Stanislav Comendant NEA source code

## Libraries ##
import customtkinter
from PIL import Image
import webview
import plotly.graph_objects as go
import sys

import math
import numpy as np

## Functions ##
def main():
    def checkbox():    # Creates the mass and diameter input boxes if the checkbox is checked, otherwise it destroys them

        if dragcheck.get():

            # Labels and input boxes for mass and diameter
            global masstext, massinp, massinfo
            masstext=customtkinter.CTkLabel(inputframe, fg_color="transparent", text="Enter mass:", text_color=labelcolour)
            masstext.place(x=83, y=640)
            massinp=customtkinter.CTkEntry(master=inputframe, placeholder_text="n/a")
            massinp.pack(pady=50, padx=0)

            massinfo=customtkinter.CTkButton(inputframe, text="?",width=15,height=15, border_width=1, border_color="gray",command=lambda: info("Changes the mass of the projectile.\nTakes float values above 0 in kilograms (metric) or pounds (imperial).\nA projectile's mass affects its motion by reducing the \ndecelerating impact of air resistance."))
            massinfo.place(y=640,x=265)

            global diametertext, diameterinp,diameterinfo
            diametertext=customtkinter.CTkLabel(inputframe, fg_color="transparent",text="Enter diameter:", text_color=labelcolour)
            diametertext.place(x=83, y=768)
            diameterinp=customtkinter.CTkEntry(master=inputframe, placeholder_text="n/a")
            diameterinp.pack(pady=50, padx=0)

            diameterinfo=customtkinter.CTkButton(inputframe, text="?",width=15,height=15, border_width=1, border_color="gray",command=lambda: info("Changes the diameter of the sphere.\nTakes float values above 0 in metres (metric) or feet (imperial).\nA higher diameter means a higher cross-sectional area, \nleading to a higher drag force and more deceleration. "))
            diameterinfo.place(y=768,x=265)

            global dragcoeftext, dragcoefinp, dragcoefinfo
            dragcoeftext=customtkinter.CTkLabel(inputframe, fg_color="transparent",text="Enter drag coefficient:", text_color=labelcolour)
            dragcoeftext.place(x=83, y=896)
            dragcoefinp=customtkinter.CTkEntry(master=inputframe, placeholder_text="Default: 0.47")
            dragcoefinp.pack(pady=50, padx=0)

            dragcoefinfo=customtkinter.CTkButton(inputframe, text="?",width=15,height=15, border_width=1, border_color="gray",command=lambda: info("Changes the drag coefficient of the projectile.\nTakes float values above 0.\nA higher drag coefficient means a higher drag force and more deceleration.\n\nSome common drag coefficients are: (none are hollow)\nSphere: 0.47\n"
            "Cube (face facing forward): 1.05\n Cube (corner facing forward): 0.8\nSemisphere (concave side): 0.42\nSemisphere (convex side): 1.17\nTetrahedron (pointy side): 0.50\nPlate: 1.17"))
            dragcoefinfo.place(y=896,x=265)

        else:
            if 'masstext' in globals():   # Destroys the mass and diameter input boxes if the checkbox is unchecked, and if they exist
                masstext.destroy()
                massinp.destroy()
                massinfo.destroy()

            if 'diametertext' in globals():
                diametertext.destroy()
                diameterinp.destroy()
                diameterinfo.destroy()

            if 'dragcoeftext' in globals():
                dragcoeftext.destroy()
                dragcoefinp.destroy()
                dragcoefinfo.destroy()

    def info(message):      # Creates an info window with a message

        global infowindow     # If an info window is already opened, the old one gets destroyed and a new one is created
        try:
            if 'normal' == infowindow.state():
                infowindow.destroy()
        except:
                pass

        # Info window with its contents
        infowindow=customtkinter.CTk(fg_color=backgroundcolour)
        infowindow.geometry("500x300")
        infowindow.resizable(False,False)
        infowindow.title("?? Info ??")

        text=customtkinter.CTkLabel(infowindow,text=message,fg_color="transparent",text_color=labelcolour)
        text.pack(pady=50,padx=10)

        mainwindow.protocol("WM_DELETE_WINDOW", lambda: close(infowindow))  # Closes the info window and the main window when the 'X' button on the main window is pressed

        infowindow.mainloop()



    global mainwindow,inputframe,dragcheck,angleinp,velocityinp,gravityinp,ystartinp,dragcoefinp

    customtkinter.set_appearance_mode(theme)
    customtkinter.set_default_color_theme(accentcolour)
    customtkinter.deactivate_automatic_dpi_awareness()

    # Main menu window
    mainwindow = customtkinter.CTk(fg_color=backgroundcolour)
    mainwindow.title("Projectile motion simulator")
    mainwindow.geometry("345x1200")
    mainwindow.resizable(False, False)

    # Main frame in the main menu
    inputframe = customtkinter.CTkFrame(mainwindow,fg_color=framecolour)
    inputframe.pack(pady=(90, 20), padx=(20, 20), fill="both", expand=True,)

    # Buttons
    runbutton = customtkinter.CTkButton(mainwindow, text="Run", width=120, height=40, border_width=1, border_color="gray", command=runsim)
    runbutton.place(x=41, y=21)

    settingpng = customtkinter.CTkImage(light_image=Image.open("settings.png"))
    settingbutton = customtkinter.CTkButton(mainwindow, text="", image=settingpng, width=40, height=40, border_width=1, border_color="gray", command=settings)
    settingbutton.place(x=255, y=21)

    # Labels and input boxes for each variable (airdrag, angle, velocity, gravity)
    dragcheck = customtkinter.CTkCheckBox(inputframe, text="Air resistance", command=checkbox,text_color=labelcolour)
    dragcheck.pack(pady=50)

    angletext = customtkinter.CTkLabel(inputframe, fg_color="transparent", text="Enter angle:", text_color=labelcolour)
    angletext.place(x=83, y=128)
    angleinp = customtkinter.CTkEntry(inputframe, placeholder_text="n/a")
    angleinp.pack(pady=50, padx=0)

    angleinfo = customtkinter.CTkButton(inputframe, text="?", width=15, height=15, border_width=1, border_color="gray", command=lambda: info("Changes the angle with the ground at which the projectile is launched.\nTakes float values between 0-90 degrees, inclusive"))
    angleinfo.place(y=136, x=265)

    velocitytext = customtkinter.CTkLabel(inputframe, fg_color="transparent", text="Enter initial velocity:", text_color=labelcolour)
    velocitytext.place(x=83, y=256)
    velocityinp = customtkinter.CTkEntry(inputframe, placeholder_text="n/a")
    velocityinp.pack(pady=50, padx=0)

    velocityinfo = customtkinter.CTkButton(inputframe, text="?", width=15, height=15, border_width=1, border_color="gray", command=lambda: info("Changes the velocity at which the projectile is shot.\nTakes float values above 0 in metres per second (metric) or \nfeet per second (imperial)."))
    velocityinfo.place(y=262, x=265)

    gravitytext = customtkinter.CTkLabel(inputframe, fg_color="transparent", text="Enter gravity:" ,text_color=labelcolour)
    gravitytext.place(x=83, y=384)
    if units=="Metric":
        gravityinp = customtkinter.CTkEntry(master=inputframe, placeholder_text="Default: 9.81 m/s^2")
    else:
        gravityinp = customtkinter.CTkEntry(master=inputframe, placeholder_text="Default: 32.19 ft/s^2")
    gravityinp.pack(pady=50, padx=0)

    gravityinfo = customtkinter.CTkButton(inputframe, text="?", width=15, height=15, border_width=1, border_color="gray", command=lambda: info("Changes the acceleration of the projectile to the ground due to gravity.\nTakes float values above 0 in metres per second squared (metric) \nor feet per second squared (imperial)."))
    gravityinfo.place(y=388, x=265)

    ystarttext= customtkinter.CTkLabel(inputframe, fg_color="transparent", text="Enter starting height:", text_color=labelcolour)
    ystarttext.place(x=83, y=512)
    if units=="Metric":
        ystartinp = customtkinter.CTkEntry(inputframe, placeholder_text="Default: 0 m")
    else:
        ystartinp = customtkinter.CTkEntry(inputframe, placeholder_text="Default: 0 ft")
    ystartinp.pack(pady=50, padx=0)

    ystartinfo=customtkinter.CTkButton(inputframe, text="?", width=15, height=15, border_width=1, border_color="gray", command=lambda: info("Changes the height at which the projectile starts.\nTakes float values above 0 in metres (metric) or feet (imperial)."))
    ystartinfo.place(y=514, x=265)

    tooltip = customtkinter.CTkButton(mainwindow, text="?", width=28, height=28, border_width=1, border_color="gray", command=lambda: info("Some helpful keybinds for quicker acess:\n\nPress 'Enter','Space' or 'R' to run the simulation.\nPress 'S' to open settings.\nPress 'Esc' to exit the program."))
    tooltip.place(y=21, x=300)


    # Keybinds
    mainwindow.bind("<Return>", runsim)  # Return=Enter
    mainwindow.bind("<space>", runsim)
    mainwindow.bind("<r>", runsim)
    mainwindow.bind("<s>", settings)
    mainwindow.bind("<Escape>", lambda e: sys.exit()) # Escape closes the window


    mainwindow.mainloop()

def runsim(event=None):
    def warning(message):       # Creates a warning window with a message

        global warningwindow     # If a warning window is already opened, the old one gets destroyed and a new one is created
        try:
            if 'normal' == warningwindow.state():
                warningwindow.destroy()
        except:
                pass

        # Warning window with its contents
        warningwindow=customtkinter.CTk()
        warningwindow.geometry("500x300")
        warningwindow.resizable(False,False)
        warningwindow.title("!! Warning !!")

        warningtext=customtkinter.CTkLabel(warningwindow, fg_color="transparent", text=message)
        warningtext.pack(pady=100,padx=10)

        mainwindow.protocol("WM_DELETE_WINDOW", lambda: close(warningwindow))  # Closes the warning window and the main window when the 'X' button on the main window is pressed

        warningwindow.mainloop()



    try:
        #  Takes from input boxes in UI
        dragbool = dragcheck.get()
        angle = float(angleinp.get())
        velocity = float(velocityinp.get().strip()) ############################################

        # Gets the gravity and starting height, defaulting to 0 m and 9.81 m respectively if empty
        if not gravityinp.get():
            gravity=9.81
        else:
            gravity=float(gravityinp.get())

        if not ystartinp.get():
            height=0
        else:
            height= float(ystartinp.get())


        # Valulues are converted to metric if the user has selected imperial units
        if units == "Imperial":
            velocity = velocity / 3.28084
            gravity = gravity / 3.28084
            height= height / 3.28084

        if 0 < angle <= 90 and velocity > 0 and gravity > 0 and height >= 0:    # Input validation
            if dragbool == True:
                mass = float(massinp.get())
                diameter = float(diameterinp.get())
                if not dragcoefinp.get():
                    dragcoef = 0.47
                else:
                    dragcoef = float(dragcoefinp.get())

                if mass > 0 and diameter > 0 and dragcoef > 0:
                    if units == "Imperial":
                        mass = mass / 2.20462
                        diameter = diameter / 3.28084

                    xpoints, ypoints, x_at_ymax, ymax, frames, frametime = airres(angle, velocity, gravity, mass, diameter, height, dragcoef)
                    graph(xpoints, ypoints, x_at_ymax, ymax, frames, frametime)
                else:
                    warning("Mass, diameter and drag coefficient values are required for air resistance.\nThey must all be above 0.")

            elif dragbool == False:
                xpoints, ypoints, x_at_ymax, ymax, frames, frametime = noairres(angle, velocity, gravity, height)
                graph(xpoints, ypoints, x_at_ymax, ymax, frames, frametime)
        else:
            warning("Angle, velocity, gravity and height values are required.\nAngle must be between 0 and 90 degrees.\nVelocity, gravity and starting height must be above 0.")
    except ValueError or TypeError:
        warning("Do not leave values blank.\nMake sure all values are numbers.")

def noairres(theta,u,g,h):
    t=0
    y=0
    xpoints=[]
    ypoints=[]
    frames=[]
    theta=math.radians(theta) # Degrees to radians

    #Simplified SUVAT equations are used
    x_at_ymax=u*math.cos(theta)*(u*math.sin(theta))/g   # Calculates the x coordinate of the maximum height
    ymax= x_at_ymax*math.tan(theta)-g*(x_at_ymax**2)*(1+math.tan(theta)**2)/(2*u**2)+h # y coordinate of the maximum height


    tmax= (u*math.sin(theta)+math.sqrt((u*math.sin(theta))**2+2*g*h))/g  # Calculates the maximum time of flight
    step=tmax/1000    # Keeps the step small enough, but also not too small

    while y>=0:
        # SUVAT equations
        x= u*math.cos(theta)*t
        y= u*math.sin(theta)*t-0.5*g*t**2 + h  # Translates upwards based on the starting height

        xpoints.append(x)
        ypoints.append(y)
        frames.append(go.Frame(data=[go.Scatter(x=xpoints, y=ypoints, mode='lines')]))

        t+=step


    # All steps have been completed, the current time is the maximum time
    tmax = t
    frameduration = (tmax * 1000) / len(frames)  # The duration of each frame in milliseconds

    # Converts the values back to imperial if the user has selected imperial units
    if units=="Imperial":
        xpoints = [x * 3.28084 for x in xpoints]
        ypoints = [y * 3.28084 for y in ypoints]

    return xpoints,ypoints,x_at_ymax,ymax,frames,frameduration

def airres(theta,u,g,m,d,h,cd):
    def calculating_Accel(t, state, m):
        x, y, vx, vy = state  # Unnpacks the state list
        v = np.sqrt(vx**2 + vy**2)  # Pythagoream theorem

        k = 0.5*cd*1.225*math.pi*(d/2)**2  # Drag coefficient

        xF_air = -k * v * vx
        yF_air = -k * v * vy
        ax = xF_air / m
        ay = (yF_air - m * g) / m

        return [vx, vy, ax, ay]


    theta = np.radians(theta)
    vx0 = u * np.cos(theta)
    vy0 = u * np.sin(theta)

    # Estimates the maximum time, as there is no analytical solution
    tmax_estimate = (u*math.sin(theta)+math.sqrt((u*math.sin(theta))**2+2*g*h))/g
    step = tmax_estimate / 1000     # Keeps the step small enough, but also not too small

    state = np.array([0 , h , vx0 , vy0])  # Initial state of the projectile (x, y, vx, vy)
    t = 0
    ymax = 0
    frames = []
    xpoints = [0]
    ypoints = [h]  # The starting height is set as the first point

    while state[1] >= 0:
        # Runge-Kutta 4th order method to find the projectile's path
        k1 = np.array(calculating_Accel(t, state,m)) * step
        k2 = np.array(calculating_Accel(t + step / 2, state + k1 / 2,m)) * step
        k3 = np.array(calculating_Accel(t + step / 2, state + k2 / 2,m)) * step
        k4 = np.array(calculating_Accel(t + step, state + k3,m)) * step

        state=state + 1 / 6 * (k1+2*k2+2*k3+k4)

        xpoints.append(state[0])  # Appends the x and y coordinates to the list
        ypoints.append(state[1])
        frames.append(go.Frame(data=[go.Scatter(x=xpoints, y=ypoints, mode='lines')]))

        # state[1] is the y coordinate of the projectile, it calculates the coordinates at the maximum
        if state[1] >= ymax:
            ymax=state[1]
            x_at_ymax=state[0]

        t += step

    # All steps have been completed, the current time is the maximum time
    tmax = t
    frameduration = (tmax * 1000) / len(frames)  # The duration of each frame in milliseconds

    return xpoints,ypoints,x_at_ymax,ymax, frames, frameduration

def graph(xpoints,ypoints,x_at_ymax,ymax,frames,frametime):

    # Checks the current settings set by the user to determine the labels
    if units == "Imperial":
        x_label = "Horizontal Displacement (ft)"
        y_label = "Vertical Displacement (ft)"
    else:
        x_label = "Horizontal Displacement (m)"
        y_label = "Vertical Displacement (m)"

    # Creates the graph and animates it
    line = go.Figure(
        data=[go.Scatter(x=[xpoints[0]], y=[ypoints[0]], mode='lines', name='Projectile', line=dict(color='blue'))],
        layout=go.Layout(
            title="Projectile Motion Animation",
            xaxis=dict(title=x_label,zeroline=True, zerolinewidth=2, zerolinecolor='lightblue'),  # Colours the axes to make them more visible
            yaxis=dict(title=y_label,zeroline=True, zerolinewidth=2, zerolinecolor='lightblue'),
            updatemenus=[
                dict(
                    type="buttons",
                    showactive=True,
                    buttons=[
                        dict(label="Play", method="animate", args=[None, {"frame": {"duration": frametime, "redraw": True}, "fromcurrent": False}]),   # Play and pause buttons
                        dict(label="Pause", method="animate", args=[[None], {"mode": "immediate"}]),],)],),
        frames=frames)

    #Creates maximum point marker
    line.add_trace(go.Scatter(x=[x_at_ymax],y=[ymax], mode='markers+text', name='Maximum Point', text=f'Max: ({x_at_ymax:.2f},{ymax:.2f})',textposition='top center', marker=dict(color='blue',size=10,symbol='circle')))

    # Creates the graph in a HTML file
    filename = "plot.html"
    line.write_html(filename)

    # Opens the html file in a webview window
    webview.create_window("Interactive Graph", filename, width=1920, height=1080, hidden=False)
    webview.start()

def settings(event=None):
    def changetheme(selected):
        global theme
        theme=selected.lower()

        mainwindow.destroy()
        settingwindow.destroy()
        main()

    def changebuttons(selected):
        global accentcolour
        if selected=="Blue":
            accentcolour="blue"
        elif selected=="Dark blue":
            accentcolour="dark-blue"
        else:
            accentcolour="green"

        mainwindow.destroy()
        settingwindow.destroy()
        main()

    def changeunits(selected):
        global units
        units=selected

        mainwindow.destroy()
        settingwindow.destroy()
        main()

    def changecolour(location, selected):
        global backgroundcolour,framecolour,labelcolour
        if location=="background":
            if selected=="Default":
                backgroundcolour=['gray92', 'gray14']   # Default customtkinter colour
            else:
                backgroundcolour=selected

        elif location=="frame":
            if selected=="Default":
                framecolour=['gray86', 'gray17']
            else:
                framecolour=selected

        elif location=="label":
            if selected=="Default":
                labelcolour=['gray10', '#DCE4EE']
            else:
                labelcolour=selected

        mainwindow.destroy()
        settingwindow.destroy()
        main()

    global settingwindow       # Checks if the settings window is already open, and prevents it from opening again if it is
    try:
        if 'normal' == settingwindow.state():
            return
    except:
            pass

    # The settings window
    settingwindow=customtkinter.CTk(fg_color=backgroundcolour)
    settingwindow.geometry("300x700")
    settingwindow.resizable(False,False)
    settingwindow.title("Settings")

    # The settings frame
    settingsframe=customtkinter.CTkFrame(settingwindow,fg_color=framecolour)
    settingsframe.pack(pady=(20,20),padx=(20,20),fill="both",expand=True)

    # Creates the labels and option menu for each setting (theme, units, background color, frame colour, button colour, text colour)
    themetext=customtkinter.CTkLabel(settingsframe, fg_color="transparent", text="Change theme:",text_color=labelcolour)
    themetext.place(x=62,y=20)
    themepick=customtkinter.CTkOptionMenu(settingsframe, values=["Dark","Light"], command=lambda selected: changetheme(selected))
    themepick.set(theme.capitalize())
    themepick.pack(pady=(50,20))

    unittext=customtkinter.CTkLabel(settingsframe, fg_color="transparent", text= "Change units:",text_color=labelcolour)
    unittext.place(x=62,y=90)
    unitpick=customtkinter.CTkOptionMenu(settingsframe, values=["Metric", "Imperial"],command=lambda selected: changeunits(selected) )
    unitpick.set(units)
    unitpick.pack(pady=20)

    backgroundtext=customtkinter.CTkLabel(settingsframe, fg_color="transparent", text="Change background colour:",text_color=labelcolour)  # Background colour
    backgroundtext.place(x=62,y=158)
    backgroundpick=customtkinter.CTkOptionMenu(settingsframe, values=["Default","Black","White","Snow","Light Slate Gray","Medium Sea Green","Light Goldenrod","Light Sky Blue","Indian Red","Hot Pink","Medium Purple"],command=lambda selected: changecolour("background",selected))
    if backgroundcolour==['gray92', 'gray14']: # Default customtkinter colour
        backgroundpick.set("Default")
    else:
        backgroundpick.set(backgroundcolour)
    backgroundpick.pack(pady=20)

    frametext=customtkinter.CTkLabel(settingsframe, fg_color="transparent", text="Change frame colour:",text_color=labelcolour)  # Frame colour
    frametext.place(x=62,y=226)
    framepick=customtkinter.CTkOptionMenu(settingsframe, values=["Default","Black","White","Snow","Light Slate Gray","Medium Sea Green","Light Goldenrod","Light Sky Blue","Indian Red","Hot Pink","Medium Purple"],command=lambda selected: changecolour("frame",selected))
    if framecolour==['gray86', 'gray17']:
        framepick.set("Default")
    else:
        framepick.set(framecolour)
    framepick.pack(pady=20)

    global accentcolour
    buttontext=customtkinter.CTkLabel(settingsframe, fg_color="transparent",text="Change buttons colour:",text_color=labelcolour)  # Button colour
    buttontext.place(x=62,y=294)
    buttonpick=customtkinter.CTkOptionMenu(settingsframe, values=["Blue", "Dark blue", "Green"],command=lambda selected: changebuttons(selected))
    buttonpick.set(accentcolour.capitalize())
    buttonpick.pack(pady=20)

    labeltext=customtkinter.CTkLabel(settingsframe, fg_color="transparent", text="Change text colour:",text_color=labelcolour)      #Text colour
    labeltext.place(x=62,y=362)
    labelpick=customtkinter.CTkOptionMenu(settingsframe, values=["Default","Black","White"],command=lambda selected: changecolour("label",selected))
    if labelcolour==['gray10', '#DCE4EE']:
        labelpick.set("Default")
    else:
        labelpick.set(labelcolour)
    labelpick.pack(pady=20)


    mainwindow.protocol("WM_DELETE_WINDOW", lambda: close(settingwindow))  # Closes the settings window and the main window when the 'X' button on the main window is pressed


    # Keybinds
    settingwindow.bind("<Escape>", lambda e: sys.exit())  # 'Escape' closes the window

    settingwindow.mainloop()

def close(window):
    try:
        window.destroy()
        mainwindow.destroy()
    except:
        mainwindow.destroy()




## Main code ##

# Sets default settings at startup
backgroundcolour=['gray92', 'gray14']
framecolour=['gray86', 'gray17']
labelcolour=['gray10', '#DCE4EE']
theme="system"
accentcolour="blue"
units="Metric"


main()