computer science
aicha1990
TeamBees-ProjectStatusPresentationFinal12.pptxCapstone Project: Flow-following Chart Generator
Adetoun Akisanya, Kennedy Donkor, Zelzah Guzman, Courtney Carrington Sumby, Jameson Travers
Project Goals
Add summary of project goals
Develop & Create a desktop application that allows its user to generate a flowchart to aid in visual representation of biological data
Gives its user the ability to first outline major decision points but then proceeds to allowing further edits and revision to made by user
Include abilities for customization as the user sees fit such as:
Color
Font
Utilization of different flowchart shapes
Courtney - Task Outline
Responsible for prompting User input in python code
Flowchart Title
Number of Entry Fields
FlowChart Symbols
FlowChart Color
FlowChart Font
Courtney - Progress
Create Basic interface for user input
Sample Code
Courtney - Progress
Create Basic interface for user input
Sample Code
Courtney - Progress
Create Basic interface for user input
Sample Interface
Courtney - Action Items
Continue learning Tkinter to improve interface
Familiarize with Flowchart terminology to ensure correct verbiage is used
Store each user input into a variable to be used further in the program
Combine input code with other teammates code for final program
Zelzah - Progress
Set up github repository for the group to collaborate on the project
The github repository contains our code and documentation
Additionally, github is a version control system, which means that it saves every version of the software we have ever written, when it was written, and what the changes from the last version were
This is useful because if something breaks we can go back to a working version from before it was broken
Also apparently git has something called “branches” which might be useful for people to work on their stuff independently, but I need to look into this more
Zelzah - Progress
Set up basic conventions for how the program will be structured
The basic pattern we will be using is called Functional Reactive Programming
This means that you just delete everything and rebuild it any time any of the data changes for your program, so you only have to worry about “what data changes” and “how do I go from this data to my UI” instead of “when this data changes, I need to figure out all the places in the UI that are affected”.
Zelzah - Progress
Set up basic conventions for how the program will be structured (cont)
The “state” variable contains all of the data you need in order to display things to the user. This includes the shape of the graph, the shapes, colors, positions, and text of all the nodes, and everything like that, but it also includes things like which node is currently selected and whether or not we’re dragging a node to a new position (and, if so, where we’re dragging it from).
If you export the state variable, then import it into a new copy of your program, the new copy will look exactly the same as the old copy.
The state variable is the only global variable that will change.
Zelzah - Progress
Set up basic conventions for how the program will be structured (cont)
The “render” method is a method that takes the state and outputs the entire UI, including both the flowchart and also the buttons that define what the user can do.
Basically every time anything changes, we delete the entire UI and then redraw it
This means we can never get bugs where something works and then suddenly fails after you export and import.
Zelzah - Progress
Set up basic conventions for how the program will be structured (cont)
Whenever a user performs an action, we should call a method that does two things, in order.
Make whatever changes are necessary to the “state” variable (i.e. if a user clicks “deselect all” it will set all nodes and edges to not be selected)
Call render()
Zelzah - Progress
Created a basic proof of concept program
Used the conventions to build a very rough GUI which allows you to move two nodes connected by an arrow
This skeleton can be extended into the full program
It is not a complete working program, but as they say, a complicated thing that works starts from a simple thing that works
My Beautiful Demo
Zelzah - Action Items
Make the shape of the diagram look like the one provided by Dr. Ray
Write automation for turning the lists of nodes and edges into the basic appearance on the right -- basically the parts of the render() method that involve making sure everything is in roughly the right place, though
(Jameson will be responsible for making it look professional)
Zelzah - Deviations
Programming is hard and it took longer than I expected to get even something very basic working
Still on schedule for now though
Adetoun - Task Outline
Insert each team member’s task
Tasked with researching, developing and integrating any statistical codes that will be utilized by team to develop project such as HMM.
Develop code for decision trees to be implemented in flowchart generator
Develop code for flowchart various flowchart buttons & windows
Adetoun - Progress
Insert each team members progress so far here
Upon further research, HMM and decision tree will not be needed
This prompted a shift to the GUI aspect of the web application
Particularly the graphics
Research available libraries of flowchart graphics and shapes compatible with Python
Currently completing a course on using TKinter
Adetoun - Action Items
Insert what we need to further complete
Develop current pseudocode into programmable language for flowchart button, fonts, and graphics
Integrate code to with teammates work using Jupyter Notebook & github
Adetoun - Deviations
Problems or changes to the original outline
Completion of Tkinter course is taking longer than anticipated
Spent a significant amount of time researching decision trees and statistical models but not necessary
Division of labor and implementation
Jameson - Task Outline
Tasked with the overall aesthetic design of the flowchart GUI
Research and find pertinent object libraries to implement within the GUI to allow for user choice with regards to the boxes, arrows, etc. within the generated flowchart
Make sure the layout of the GUI is easy to navigate while providing an adequate user experience during use of the app.
Jameson - Progress
Thus far, we found a good python library of shapes to use with flow chart generator: pyglet. We will be using it to implement choice for the user in regards to how their flowchart will look once generated.
Have been doing some training classes/exercises for Tkinter to familiarize myself with framework in order to create a draft of the final layout.
Jameson - Action Items
Need to finish Tkinter training and become familiar with the GUI framework it provides.
Need to finish a first draft of the Generator GUI layout.
Work with Adetoun on implementing the pyglet library
Plug underlying code from other group members into the input/button layout.
Jameson - Deviations
No problems or changes from the previous outline.
Just need to finish my Tkinter introduction exercises and generate a rough draft of the layout.
Once we have a general layout we can begin to implement the shapes library underneath.
Kennedy - Progress
Responsible for ensuring the final output of the file
Ask the user if they are satisfied with their input
Print the flowchart to screen
Output the file into a folder of choice for the user
Kennedy - Sample Code 1
import os.path
def main():
file="abcdefg"
userselect=input("Yes or No: ") #asking the user if they are happy with their work
if userselect=="Yes": #what happens if the user is happy
spath=input("Enter where you want file saved: ") #the directory where they want their file saved
filename=input("Name of the file: ") #naming given to the file
Kennedy - Sample Code 2
fullname=os.path.join(spath, filename + ".txt")#making it a text file
outputfile=open(fullname, "w")#saving the file
finalfile=file
outputfile.write(finalfile)#writing what to save in that file
outputfile.close()
Kennedy - Sample Code 3
print()
print(file)#printing the file to the screen
else:
print("Double check your work")
#code adapted from codegrepper.com
main()
Updated Project Timeline
Week 5: September 21st - Present pseudocode & code infrastructure
Week 6-8 September 28 to October 12 - complete program requirements
Week 9 October 19 - Finish & refine program components and code
Week 10 October 26th - Finish & refine final report
Week 11 November 2 - Finish & refine final presentation
