Posted on

Denise’s Status Report for 2/26

This week I worked on researching different .SVG converters since we decided to move our vectorization process into the software side in order to avoid having to compare different frames with a temporal approach. The two main methods I looked into were using Potrace and Vtracer. In the end we decided to go with Vtracer since it works with colored .PNG files as well and has better image fidelity; meaning that the .SVG resembles the image more accurately.

I also designed a mock up of our GUI in Figma and discussed with Ronald what features/buttons we should add for better user interactions.

GUI: https://www.figma.com/file/iI5Mw8cfi4QE14hJeFnFHg/DrawBuddy-GUI?node-id=0%3A1

I worked on putting together a design proposal presentation and focused on the use-case, use-case requirements, and system approach/implementation plan.

https://docs.google.com/presentation/d/14MaQNsqbtGYA0_ZN-x0DoQWcdriZ-3-VRN1r-oDmobM/edit?usp=sharing

 

Posted on

Team Status Report for 2/26

What are the most significant risks that could jeopardize the success of the project? How are these risks being managed? What contingency plans are ready?

The most significant risks currently are ensuring that the images can be vectorized efficiently since the latencies have not currently  been tested although it looks promising since the algorithm Vtracer uses also includes line simplification which would reduce the number of point per primitives. If Vtracer is not fast enough then we will also consider PoTrace or and reverting back to vectorizing with Computer Vision using a temporal approach

System Design Changes:

This week we pivoted our design to do our vectorization on the software side with the help of Vtracer, a Python .PNG to .SVG converter. We considered using other .SVG converting packages like PoTrace but decided to go with a Vtracer due to it’s support for colored images in case we do want to extend for our stretch goals of adding colored diagrams and it also maintains better fidelity of the original image when compared to PoTrace. This change in decision does not incur any additional costs to our project. We are also looking into methods to remove having the user need to agree to receive a message from a peer in order to make the user interaction smoother. This is still currently being researched but should not cause any major changes to the system.

The schedule has not changed. Currently our message passing is successful and within our latency bounds and our CV is able to detect roughly straight lines without much difficulty.

Posted on

Lisa’s Status Report for Feb 26, 2022

This week I mainly focused on the design presentation. I was the presenter for the design review presentation, so I also spent a few hours preparing and practicing for the presentation on Wednesday. For the presentation slide deck, I mainly worked on the image filtering portions (like OpenCV and line detection), modified the Gantt chart, and added helpful visuals as well. While preparing for the presentation, I spoke with both Denise and Ronald on the aspects of the project that they were more familiar with (like the image vectorizing and the sockets software)

For the actual implementation of the project, I looked into alternate approaches for line detection in the image filtering/vectorizing aspect (as opposed to relying on the hough detection algorithms in OpenCV, which weren’t as reliable) of our project and discussed them with Denise. I also looked into PyGui so that Ronald and I can start working on developing the user interface starting next week. We also intend to get a basic framework up by the end of next week for the user interface. So far, we are on schedule.

Posted on

Ronald’s Status Report for Feb 26, 2022

This week I haven’t done much of the writing I’ve been looking into PyGUI and trying to learn how it works so that in the following weeks I can help Lisa out in writing the GUI code for the program.

As of this moment we are still on schedule but the coming weeks will be much better for gauging how on schedule we are as right now it is just the beginnings of the next steps of the project.

Next week I would like to have a shell of what the GUI will look like, maybe it won’t be super interact-able but it’ll have the right looks or vice versa.

Posted on

Lisa’s Status Report for Feb 19, 2022

This week, I worked on developing code for the computer vision section of the project – mainly, line detection. Denise and I discussed the intersection between what the computer vision algorithm would output and what the vectorizing code would need in order to vectorize the individual lines. We settled on an implementation that allows the computer vision code to send a list of line endpoints to the vectorizing code that she will develop. I also noticed that my current code for line detection occasionally classified one line as two different lines – one thing I will have to work on next week is fine tuning parameters to ensure that lines don’t get double counted. Part of this lies in the cv2.houghLines() function in my code and the parameters it takes in, but it also will also require further checks in the algorithm. I’ve also worked in the presentation for the design proposal this week. So far, we are on schedule.

Posted on

Denise’s Status Report for Feb 19, 2022

This week I took a look at several algorithms to reduce the amount of points within a line such as the Douglas–Peucker algorithm, and the Visvalingam–Whyatt algorithm. The Douglas-Peuker algorithm has a faster runtime however the Visvalingam–Whyatt algorithm is more straightforward in terms of complexity, making it a viable back up. I also researched ways to convert an SVG file to an array of points and back such that the user can send their diagrams as SVG files to display to connected peers, but also be able to modify the primitives on their end which would be easier as an array of points.

I also worked on the use case, use case requirements, solution approach on the slides and mocked up the GUI using Figma. Currently we are on schedule. Next week I will be working with Lisa to finalize our vectorization approach and start writing code to convert files into SVGs. We will also be taking a look into how we can compare frames to subtract the lines drawn in previous frames using a temporal approach.

Posted on

Team Status Report for Feb 19, 2022

This week a lot of the work done by the team was spent on getting the Design Proposal presentation. Sizable progress was then made on the sockets server for sending the code to various users.

The biggest risk that jeopardizes our project is currently converting the image to uniform lines and polygons within our latency requirement. Currently there are many lines generated by our CV software but in order to improve the usability of our project we need to reduce the lines such that we only have a single line for each connected component that the user drew. This would also make rendering more efficient since the software will not need to process as many lines. We are taking look into using temporal information ie having the user draw a line/polygon 1 by 1 and then hold it up to the camera after each line. We are also looking for algorithms that can simplify the number of points within lines. One backup plan is to take the image as a PNG and convert it to a SVG using potrace or a similar python library.

As of now there have been no changes to the current design of the system. The current schedule has been updated to look like this so that we can slot in some time for leniency.

Ronald got the server working and was able to test sending an image to Denise which works so in the coming week he is going to run more tests to see how long it takes for many different vectors to send and ensure that we are reaching our latency goal for the server.

This is why one of the risks is the server being slower than we would like because we will have to find some other way to send the svg files and not much research has been done into that.

Posted on

Ronald’s Status Report for Feb 19, 2022

This week I begun the actual programming work on the server and was able to finish it a week ahead of schedule which allows us to slot in some leeway time into the overall project plan. Using sockets and some other python libraries I was able to send jpeg images and svg vectors to myself and while connected to my personal at home wifi I was able to send a jpeg to my roommate. Then I checked if it would work while connected to campus wifi and I was able to send a jpeg to Denise, my teammate.

The project is currently slightly ahead of schedule since the server software was finished quicker than anticipated but there is still the issue of integrating everything together but that will have to come later.

For next week I would like to do some testing on the latency of sending image vectors and would like to get some work started on the GUI for the application that users will use to send the actual images to each

other.

Posted on

Denise’s Status Report for 2/12

During this week I helped put together the use case, use case requirements, and solution approach slides for our proposal presentation. After everyone added their content, I revised each slide to be more concise by reducing the amount of words for better readability.  After that I spent a couple of hours figuring out what I would say in each slide, practicing, and revising the presentation to fit it in under 12 minutes.

We currently are on schedule, although the schedule may need to be revised for more slack time.

This week I will work on continuing to research how to vectorize images, and then also take a look into strategies to translate and scale the vector objects. I will also look into algorithms to reduce the amount of points generated from CV.

Posted on

Team Status Report for Feb 12, 2022

During the past week, our team mainly focused on finalizing our project design and proposal presentation. We also considered some technical challenges that we could come across while working on the project.

One main significant risk that could be posed is if the server code takes too long sending images or vectorized files, since we are unsure of how long it would take to transfer all of the data in those files from client to server to four other clients. One way to manage this risk is to make sure we have to wait until the server code is working and then test it.

Another challenge will be ensuring that we are able to accurately recreate the hand drawn image as a vectorized one. We will need to research computer vision algorithms that can recognize lines that are not perfectly straight as lines. This is something that we intend to do in the coming week.

The main thing we accomplished this week was the proposal presentation on Monday, which went very well. No changes have been made to the existing design of the system that was presented on Monday, and we are on schedule so far to complete the deliverables as laid out in the Gantt chart in the coming weeks.