Luis Carrasco

BU Art Gallery

Mon, 23 May 2011 14:58:51 +0000

This is still an ongoing project for BU IS&T Innovation. It consists of an iPhone app that can recognize artwork being displayed at a gallery and give more information about it. These are some screenshots of early development:

AR BU Maps

Mon, 23 May 2011 14:45:43 +0000

This is an iPhone app that displays all of Boston University Maps records on an augmented reality view. This project I did while working as a student in Boston University IS&T Innovation.

AR Maps Video

BU Live Bus

Mon, 14 Mar 2011 03:12:46 +0000

Boston University Students, here’s what you’ve been waiting for. Do you use the BU Shuttle bus? Do you hate waiting outside in the heat or in the cold? Then BU Bus can help/ Bu Bus shows the real time position of the BU Shuttle Bus fleet along with a 99% accuracy. Other features of the App Include: – Full bus schedule, including late night schedule – Full Documentation of all stops, including pictures – Location Aware, so you know which stop is closest to you

If you encounter any problems, please email me or leave me a comment and I will fix it as soon as I can.

Linux Hacking

Wed, 12 Jan 2011 18:20:07 +0000

Intercepting schedule() system call and replacing with own scheduler. Not fully working due to the fact that schedule() never returns.

InteceptingCalls

Video Server

Wed, 12 Jan 2011 18:13:04 +0000

Implementation of multithreaded video server using posix synchronization and custom kernel synchronization using ioctl.

CS552-HW2-TheriaultTowneCarrasco

Ramdisk Filesystem

Wed, 12 Jan 2011 18:04:58 +0000

Implementation of an iNode based filesystem in Linux. The filesystem lives in ram, but it’s accessible to all processes using ioctl calls.

https://github.com/luiscarrascob/CS552-ramdisk-kernel

Senior Design Project

Sat, 04 Sep 2010 08:43:44 +0000

NightHawk NVS is an, in-car camera night vision system that aids drivers in locating obstacles, road signs, and other dangers at night. The system consists of an externally mounted front-facing camera, a processing unit that constantly analyzes each frame for potential dangers, and a touchscreen user interface system. This system uses a series of cutting edge image processing and artificial intelligence algorithms to determine whether individual objects in an image represent a threat to the vehicle. The system is aware of its surroundings and can determine different kinds of dangers in a wide range of situations. When analyzing its surroundings, the system attempts to locate objects that have a high likelihood of entering the vehicle’s path. When searching for obstacles, the system runs the frame through a Neural Net to see if any people, animals, or obstacles are in the vehicle’s path. The system locates and marks common road signs and informs the driver of them. To find signs, the system uses advanced template matching algorithms and techniques to provide highly accurate results and minimize false positive detections. The system also locates lanes on the road and alerts the driver if the vehicle is not within lane boundaries. The lane detection uses thresholding and contour mapping to provide reliable and accurate highlighting of the lanes. The techniques utilized in the system allow it to run in real-time up to 30fps and yield higher accuracies than other prototype night vision systems for cars.

http://www.bu.edu/today/node/11275

Video

Boston Car Buyers

Wed, 01 Sep 2010 03:26:18 +0000

Designed Boston Car Buyers’ Website. With get a Quote page.

Final Design

Silverlight Computer Vision

Mon, 31 May 2010 02:56:25 +0000

Trying to implement some computer vision algorithms in silverlight. Not doing much so far

Image Registration

Sun, 18 Apr 2010 06:17:37 +0000

This program implements image registration. It first finds a set of 50 corresponding points between images. Then it runs a registration algorithm that calculates the translation and rotation needed to align the images. And finally it overlays the images on top of each other and calculates the error.

Method and Implementation

Finding Corresponding Points

For this algorithm I found a set of 50 corresponding points

The method I used was OpenCv’s Good features to track method

This is the 50 points found for the first image

This is the 50 points found for the second image

The algorithm then found the controid of the image using the 50 points. This is shown in red in the images above

Finding the angle Theta

To find the angle I used the method given in class where:

Theta = sum(y’(r,i) * x’(l,i) – x’(r,i) * y’(l,i))/sum(y’(r,i) * x’(l,i) + x’(r,i) * y’(l,i))
(where it sums over all points found on both images)

This is the rotated version of image 2 using OpenCv’s cvWarpAffine to rotate the image after the angle was found

Calculating the Error

I used OpenCv’s cvCanny to help me calculate a more accurate measure for the error (I think).

I used cvCanny to calculate edges on both the images, I then compared pixel by pixel and counted the pixels that did not match each other. Finally, I divided this number by the number of pixels in the image and used the result as my measurement for the error

This is both imaged overlayed on top of each other using the centroid as the point of reference. Note that the error is shown at the top

Experiment and Results

Finding Corresponding Points

This part was challenging because it is difficult to find a method for automating finding corresponding points that is accurate

At first I tried Implemented an Active Contours algorithm that spaced 80 points as fairly as possible to start with and have it little by little adjust itself to the inside and outside contour of the shape. This would have been very efficient had I finished writing the algorithm!

Next, I used openCv’s goodFeaturesToTrack algorithm. This proved to be a useful algorithm, however it picks points that are the most unique to an image, which in this case is not the best thing to do

Finally I implemented the same goodFeaturesToTrack algorithm, but this time I ran it on the edges of the image. I found the edges using cvCanny thresholded at about 200, which is the gray color that the biggest edges have. This method porved to be good ebough for the purposes of the assignment, so I used it.

Finding the angle Theta

This was the most straight forward part of the assignment as I followd the algorithm we derived and discussed in class

This algorithm found the angle accurately and helped me rotate the image about the centroid very accurately too

Calculating the Error

I tried a few different methods of calculating the error and eventually used the one I thought was the most fair:

At first I tried calculating the mean distance betweent the found points and using it as the measure for the error. The problem with this approach is that the points don’t necessarily correspond to each other, but that does not mean that the image was not registered correctly. So I figures I would use a measure that did not use the points to calculate error but rather tha actual results.

I tried then going pixel by pixel and incrementing a counter for every pixel that matched. Then dividing this number by the number of pixels and using that as a measure for the error. This is an “ok” measure, however, the images might match very well, but if one is a little darker, this approach will yield a huge error

So I then decided to go the edge way again. I repeated the process described above but on the edges of the image. This proved to be an accurate measure og the error

Discussion and Conclusion

Accuracy Discussion

It was very interesting to see the effect that the number of points found had on the algorithm. I tried different number of points with the error increasing for numbers less than 50 and greater than 50. I did not try to keep increasing the number of points to see if the error would go down again, but I speculate that it does

My final error was of 0.08%

My rotation angle was of 9.16 degrees

My translation was 9px on the x and 16px on the y

Here again is the transformed image overlayed with the original…as asked in the assignment

Source Code