Posted on

Team Status Report for April 9, 2022

Currently, the most significant risk remains similar to that of last week’s, which is the method that we use to display the different components of the SVG file on the whiteboard such that we can also be able to edit them. Our current solution for that is to parse each line of the SVG file into either a line or polygon, and then use a PyGUI library to display the line or polygon onto the whiteboard, adjusted for proportions.

A change that we had to make was that we want to be able to edit out the background whenever a user holds up a piece of paper up to the camera, so that the background doesn’t get vectorized and added to the SVG file. No additional costs will be incurred because of this added feature.

We are on track. We were able to make good progress on converting the SVG file into editable components and should be able to complete that next week. We were also able to get sending an SVG through the GUI working and will work on the receiver code in the coming week. Next week we also hope to fully integrate our SVG parser with code to display objects on the whiteboard, and also make some progress on eliminating the background when a user holds up a drawing for the app to vectorize.

 

Posted on

Lisa’s Status Report for April 9, 2022

This week I implemented function that took a parsed SVG file (which Denise wrote the code for) and drew lines on the whiteboard. The function takes in a list that consists of the line endpoints and also parses the parsed SVG file to obtain the width and height of the image by extracting the values from the second line of the SVG file. I also wrote code that simply displays the vectorized image on the whiteboard for now, but would like to replace it with code that allows translation of the elements (and also only displays lines and polygons).

We had to modify the schedule a bit for now, which we discussed during the demo on Monday. Next week, I hope to complete integrating the SVG parser with the code for creating translatable and scalable elements on the whiteboard.

Posted on

Denise’s Status Report for 04/09/2022

This week I implemented an SVG parser to parse through an SVG file line by line and extract the endpoints of the path in order to produce straight lines. I then modified this feature by having it parse through all the points within a path and extracting only the points that produce an angle of less than 100 degrees such that points that form obtuse angles with their neighbors are removed. This method helps reduce the complexity of the shapes by removing points while also enabling us to produce polygons as opposed to just lines.

I researched different methods of cropping the image captured by the camera such that we only capture the paper and the diagram on it. Currently our approach is to greyscale the image, apply another filter to make it black and white, and apply a morphological erosion and dilation to remove noise. After that we will apply the openCV border detection and then use that to crop the background of the image. It is currently a work in progress.

We had to modify our schedule a little bit this week but we are currently on track. Next week I hope to finish this portion of removing the background image and then help Lisa integrate the SVG parser with the code to render the SVG files onto the whiteboard.

Posted on

Lisa’s Status Report for April 2, 2022

This week I worked with Denise on combining vectorization logic with the GUI. We also discussed on how to handle identifying lines as straight lines, and ended on the solution of handling it by letting the user identify which lines should be straight after processing the image.

We are a little behind schedule. One setback this week is converting the vectorized SVG file to something that can be displayed on the whiteboard on the GUI. We’ll have to parse the SVG file and use the GUI interface to display the objects on the whiteboard. For now, we’re trying to stick to just getting lines to show up on the whiteboard for the demo, and we’ll try to work with other shapes in the coming weeks. We’ve made a lot of progress on this setback though, and should be able to get back on track by next week.

Next week, we want to be able to be able to complete a full vectorize-to-GUI pipeline. We also want to try to implement sending and receiving vectorized images between users within the GUI.

 

Posted on

Ronald’s Status Report for April 2, 2022

This week I have begun integrating the current GUI code that we have for the project with the server code that I had previously created. This might prove to be a harder task than imagined since it requires a significant amount of alteration to the current code.

I don’t think that we are behind schedule but we’ll have to wait and see for next week if I can get this done in time though I think I should be able to.

As stated next week I hope to have a working multi-user application that can send images to one another.

Posted on

Team Status Report

The most significant risk as of now is identifying an efficient method to display the different components of the .svg file onto the whiteboard. We need to display the components in such a way that it is easy for a user to edit each component individually. Current methods and our backup plan involves taking each independent object and outputting each one as a separate .png file onto our whiteboard. We could also write our own parser to iterate through the objects of a .svg file and draw each component as it’s individual object. More research will need to be done to decide on a method.

The biggest change we may make is that we may implement the goal of straightening lines as a feature on our GUI such that the user can explicitly mark which lines they would like to be straight in order to reduce the complexity of the computer vision algorithm on the pre processing side. This will incur no additional costs.

We are a little behind however there have been no changes to our schedule since we are aiming to get back on track by the end of this week.

Posted on

Denise’s Status Report for 4/02/2022

This week I finished modifying the use-case requirements, abstract, and testing portions of the design report in preparation for our final report. I also integrated the computer vision component with the vectorization portion such that once the image is captured; it will be written as a .jpeg file to DrawBuddy/vectorization/inputs where it will then be fetched by a call to the VTracer API and vectorized as a .svg file in the DrawBuddy/vectorization/results folder.

I also began looking into ways we can display .svg files not as .pngs onto our whiteboard display since this was a problem we did not account for. We had assumed svgUtils had additional function for displaying .svg files but currently pyQt looks promising. The remaining work to integrate the rest of our project includes taking the .svg file and outputting it onto our virtual whiteboard.

In terms of identifying straight lines, I discussed with Lisa and  we’re thinking of pivoting to performing this on the post processing side such that the user can explicitly mark which lines they would like to straighten as opposed to trying to produce and algorithm that could estimate the user’s preferences.

I am a little behind schedule since setting up the whiteboard and displaying objects onto it were setbacks that we did not expect. However this is a minor setback and we should be able to get back on schedule within the next week or so.

Next week we hope to have a fully integrated system for vectorization. such that  a user can click our vectorize button and it will take whatever image the user has and output it onto the whiteboard. More work will need to be done to filter the noise from the image and send the images to connected peers.

I also hope to begin working on the translation and resizing features of objects within the image on our whiteboard.