Mapalyze

A web app that takes multiple floor plans and generates a 3D layout of a building appropriately marking stairs, hallways and rooms, with navigation features built on top.

Sprint 2

https://asrarfarooq.github.io/Mapalyze/

Sprint 3

• UI/UX Improvemnts - Tailwind -Ehtisham
• Backend Authenication with C# - Huye
• 2D → 3D implementation finally figured - Asrar
• Reserach on cloud deployment - Nikhil

Sprint 4

• Discovering a Unity-Replacing Gem: "react-planner" Library | Asrar
• Testing and Isolating the Library, Resolving Dependencies, Seamless Integration into the Main App | Ehtisham
• Branch Mergers and Conflict Resolution | Huye & Mai
• Creating an MVP for Presentation, uploaded to Canvas | Team 3
• [Elevating UI/UX with Tailwind CSS: Demoed in the meeting]
• [Continued Code Refactoring - Continously working on that (Demoed in meeting)]
• [Meeting with Brian McLendon - Discussed in meeeting as well]

Sprint 5

• Finishing app integration and testing | Asrar

  • This task was demoed in the meeting when Asrar used iframes to integrate the editor into the main app.

• Adding an SVG parser | Nikhil

  • This task was also demoed in the meeting when Nikhil showcased the Open CV algos to start the work on the parser.

• Integration of the SVG parser and the planner | Huye

  • Main App Integration Link
  • This task was done by Huye and demoed to the T.A as well showcasing the parsing of JSON directly to the planner without the need for import.

• Continuing Code Commenting and Code Refactoring| Ehtisham

  • Ehtisham Added code comments and removed redundant classes and modules to make the repo efficient.

• Merger resolutions

  • This was also discussed in the meeting.

• Continuing UI/UX improvements | Asrar

  • Asrar added some new text on Pages (About Us), added some buttons and button logic and also reviewed the design of the app.

Sprint 6

• Continuing UI/UX Improvements
  • Asrar Added new buttons and improved the main interface to some extent.
• Integration of Azure
  • Ehtisham and Asrar Deployed both the App and Editor on Azure and linked them together as well.
• Azure Tailwind Issues Resolution
  • This was fixed by Ehtisham before the App deployment.
• Code Refactoring
  • Huy worked on this one and added code comments for better detailing out the code.
  • He also updated appinterface to import json file and to post json file to react planner backend and added comments to this one as well.
• Research on API Endpoints in Azure
  • Mai worked on API end point research which will help us in subsequent sprints to determine how we go about connecting and deploying our own editor API
• Continue Researching and Refining the Base Parser
  • As discussed in the meeting by Nikhil that he is continuously working on refining the base parser is going forward by adding parsing support for more elements
• Working on Finishing JSON Class for Vertices
  • This was done by Nikhil and he's work can be found in the link.

Sprint 7

• Continuing UI/UX Improvements
• Code Refactoring
• Continued Integration/Continuous Deployment (CI/CD)
• Integration of Database into Azure
• Implementation of Login/Signup after Database Deployment
  • We identified a critical issue in the app where users can bypass the login process. Even without successful authentication, users can access the main app through the navigation header/bar.
  • We decided to fix the problem in sprint 7 and will continue doing it in sprint 8
• Implementing the First Phase of Parser-Editor API
• Starting Research on Navigation inside 3D Models for the Second Half of the Project

Sprint 8

• Continue UI/UX Improvements
  • The Login & SignUp was refined and other improvements to visitations were done as well.
• Continue Code Refactoring
• Continued Integration/Continuous Deployment (CI/CD)
• Do More Research on Integration of Database into Azure
  • The research was done was will be demoed next week, since it is not on GitHub
• Fix the login/signup Logic Problems on Current App for Doing Database Deployment
  • This was fixed by Huy by adding protected routes.
• Continue Implementing the First Phase of Parser-Editor API
  • A video demo of the First phase of parser.
• Continue Research on Navigation inside 3D Models for the Second Half of the Project
  • This was scraped due to a change of plans after careful research, this step required sophisticated pathfinding algorithms such as A*, the determination of specific floors is very hard to implement and we decided to put off this feature for now.

Sprint 9

• Persist in refining code structure and remove redundant code

  • We removed some previously created yml files which were enabling us to deploye the app statically, but for the merger of the new backend we needed to get rid of them. This way we reduced some redundancy that allowed us to move forward with our vision.

• Execute phased deployment strategy:

  • As discussed in the meeting, we planned to execute phased deployment strategy since we were unsure of some of the things that would be used for deploying all of our micro-services. This would allow us some time to test our micro-services before we have public endpoints sending API requests. We did this by containerizing the Mapalyze (FrontEnd, Backend), ReactPlanner (FrontEnd, Backend), & the Parser into three different Web App services or App Spaces as Azure calls them. A demo was shown on how these services would communicate between each other.

• Parser Microservice Deployment:

  • We used this guide by Microsoft to help us deploy our Parser as a micro-service in Azure. The results were promising though further testing and refinement is needed, the full deployment will stretch to next sprint, though we should have an early demo by next week. All the deployment is already done and the app is up and running locally as well as online. The code can be found here along with all the workflows.

• Research Frontend - Parser linkage & Initiate Development

  • As discussed in the meeting this linkage was crucial in the development phase as it was the only workflow letting us send the image data to the parser and from there to the react planner, the research was done and discussed in the meeting that we could leverage the use of Azure App Spaces.

  • Here's a snapshot of how are getting the pipelines ready in Azure App spaces though it wasn't in the Sprint 9, we went a step ahead to make sure things go well as planned.

  • Snapshot of Azure App Spaces

• Research File Upload and storage in Azure DB Research Parser - Editor linkage & Initiate Development

  • As previously discussed on multiple occasions, the image upload is an important element in the whole CI/CD pipeline as it gets the image data from the user and tries to convert it to compatible JSON.
  • We have been doing extensive research on how to utilize blobs or Azure File Storage options. Here is a research document, providing extensive detail about how we plan to add this feature to the architecture.

• Fix Merge Conflicts, Reduce Branches

  • For this artifact we went ahead and deleted redundant branches and also have merged successfully everything to the main. This merger includes the latest Tailwind enhanced frontend and the good old dotnet backend used in hand with SQL database auth from azure to authenticate the user and let them use the app. For further development all the team members will now branch off of the new main to work on their individual tasks.
  • The merger introduced a lot of conflicts which were efficiently resolved by the team.
  • Here is the branch merger commit hash which showcases in detail the things that were merged.

• Overall this sprint saw a lot of changes in terms of branches, tech stack, deployments as well as pre-laid out plans of CI/CD, pipelines, architecture, which will surely help our team achieve the goals of upcoming sprints.

Sprint 10

• Completion of Deployment Process for Three Separate on Azure
  • We deployed everything to Azure, we used Azure App Services and App Spaces to deploy our codebase via VSCode CLI.
  • Post deployment we encountered functionality issues which we'll fix in the upcoming sprint.
• Enhanced Line Detection in Parser Module
  • This was done by Nikhil to improve the edge detection and will be demoed in the next Weekly meeting, since there's no way of showing it here.
• Initiation of Research on Pipelines and API Endpoint Integration
  • The research was laid out to see how are we finally going to connect these services offline as well as online. The research doc will be posted on our site.
• Research and Development on Dynamic Deployment Using Azure App Services and App Spaces
  • This artifact was demoed to the TA, in the last sprint where we deployed the flask app, using azure app spaces
  • The deployment detail and the links can be found here
• MVP Testing and Bug Fixing Post-Deployment
  • We are rigorously testing the product we have up until now, we are facing a lot of unexpected issues post-deployment and have identified majority of them and will try to finish fixing them in the next sprint.

Sprint 11

• Fixed deployment issues with Azure.
  • We attempted to resolve the deployment issues with Azure, but .NET was not compatible with our version of the parser. We also tried running the parser as a separate micro-service, but that was unsuccessful. Consequently, we proceeded with our fallback plan.
• API endpoints for Mapalyze
  • We added API endpoints for Mapalyze that enabled users to import floor plans successfully. These floor plans were then sent to the backend of ReactPlanner through an API call. The implementation can be found here.
• Work to get everything operational locally.
  • We successfully demoed our MVP to the TA. Before finalizing the MVP, we made some design modifications to our existing architecture.
  • We integrated the Parser with the ReactPlanner backend, as it was more feasible to do so. The RP backend is written in JavaScript, which integrates more smoothly with Python than our .NET React App (Mapalyze).
  • 
• Added file upload on the Main Page of Mapalyze
  • In line with the API artifact discussed earlier, we implemented a file upload feature on the Main Page of Mapalyze and modified the backend of ReactPlanner to support these changes. The specific code changes can be viewed here.
• Resolved the Parser resolution issue for various monitors
  • We addressed the resolution issues our parser had with screens of different sizes by enlarging the canvas to accommodate various screen sizes. The updated parser code is available here. We also improved line detection by scaling input images to better fit spaces in the floor plans.
• Conducted additional testing
  • Further testing uncovered issues with IP configurations during login and some problems with the folder structures set up to retrieve JSON files. We plan to address these in the upcoming sprint.

Sprint 12

• Set up folder directories for JSON files
  • For this requirement we added a dedicated folder that stores the JSON files obtained after parsing, this ensures that the planner is able to generate the floor plans properly after fetching the JSON. Here is the code for elaboration Github Commit Link
• Fixing retrieval directories for uploaded floor plans
  • For this artifact we setup an uploads folder that would store the upcoming uploaded image that was sent via an API call from the Mapalyze front end. This would ensure the image is stored in a proper pipeline before being sent to the parser. Github link for the code is here.
• Resolve public access/IP issues in Azure firewall.
  • We faced issues with login when any user who didn't own the database or whose IP wasn't added to firewall was blocked from the traffic. We made sure all valid user's are able to get into the app by setting up new firewall policies.
• Complete the SQL DB update on the new Azure Resource Group
  • Our previous DB is no longer operational as it was on a free subscription, and we have exhausted the credits allocated to it. We have now migrating to a new, identical DB, maintaining the users and hashes.
  • 
• Implemented holistic changes in the Frontend
  • We plan to continue refine minor front-end and UI/UX components to make the app user friendly.
• Test the MVP
  • We again are continuously testing the app which revealed that the parser is taking a lot of time for images with multiple edges, again this issue will be fixed in future sprints if possible.

Final Sprint

• Front-End Documentation
  • Attached a document detailing the Front-End, Link.
• Back-End Codebase Documentation
  • Attached a document detailing the Back-End, Link.
• Database and Architecture Documentation
  • Attached a document detailing the DB & Arch, Link.
• Parser Documentation
  • Attached a document detailing the Parser, Link.
• Minor Front-End Enhancements
  • We made some minor enhancements regarding colors and elements, to make the UI user friendly and neat.
• Testing
  • We also did additional testing and we think we are finished with the whole deployment.