Expected Value in MATLAB

From Wikipedia:
“In probability theory, the expected value of a random variable, intuitively, is the long-run average value of repetitions of the experiment it represents.”

I decided to give it a try in MATLAB.

% Expected Value of a Die
numOfIterations = 100000;
meanArray = zeros([1 numOfIterations]);
values = zeros([1 numOfIterations]);

for i = 1:numOfIterations
   % Get a random value between the range of [1 6]
   values(i) = randi(6);
   % Calculate the mean so far
   meanArray(i) = mean(values(1:i));
end

%Plot
plot(1:numOfIterations, meanArray);

% Display the latest calculated mean
disp(meanArray(end));

This is the result:

ExpectedValueMATLAB

Advertisements

OpenCV 3.4.1 + CUDA Hello World

The following code creates 3 floating-point matrices in RAM (imgA, imgB, imgC), and also 3 on the GPU (cuImgA, cuImgB, cuImgC).

Initializes imgA with 1.0 and imgB with 0.13. Then subtracts them using the GPU, copies the result from the GPU to RAM and displays the resultant image.

Hope this helps!


#include "iostream"
#include "opencv2/opencv.hpp"
#include "opencv2/imgproc.hpp"  // Gaussian Blur
#include "opencv2/videoio.hpp"
#include "opencv2/highgui.hpp"  // OpenCV window I/O

using namespace std;
using namespace cv;

int TEST_OpenCVCUDA()
{
	// Declare operands
	Mat imgA(Size(512, 512), CV_32F);
	Mat imgB(Size(512, 512), CV_32F);
	Mat imgC;

	cuda::GpuMat cuImgA, cuImgB, cuImgC;

	// Display information on the current environment setup
	cout << "CUDA Device count: \t" << cuda::getCudaEnabledDeviceCount() << endl;
	cout << "Cuda Device: " << cuda::getDevice() << endl;

	// Set the images to different values
	imgA = 1;
	imgB = 0.13;

	// Copy data from RAM to GPU
	cuImgA.upload(imgA);
	cuImgB.upload(imgB);

	// Perform arithmetic operation
	cuda::absdiff(cuImgA, cuImgB, cuImgC);

	// Download result to RAM from GPU
	cuImgC.download(imgC);

	cout << "Image A: " << imgA.at(255, 0) << endl;
	cout << "Image B: " << imgB.at(0, 255) << endl;
	cout << "Image C: " << imgC.at(255, 255) << endl;

	// Display image
	imshow("imgC", imgC);

	// Wait for a keystroke in the window
	waitKey(0);

	return 0;
}

int main()
{
	return TEST_OpenCVCUDA();
}

Building OpenCV 3.4.1 + CUDA

Requirements

  • CUDA Toolkit (I’m using version 9.1)
  • OpenCV (I’m using version 3.4.1)
  • CMake (I’m using version 3.10.1)
  • Visual Studio 2017

Process

Open CMake and selecte the sources folder as well as the folder where the build files will be generated (I created a folder named buildDATE).

Click on “Configure”, it will take sometime to configure everything, it may ask you to select the “Generator” (in this case select Visual Studio 15 2017 Win64).

Click on Generate.

Go to the build folder and open the OpenCV.sln file (the solution for Visual Studio).

Under CMakeTargets, right click on ALL_BUILD and Build. This will take a long time (it took over 2hrs in my case).

I  ran into a problem where the module/opencv_highgui was throwing linker errors, I had to manually add window_w32.cpp to the opencv_highgui project to get it to link correctly.

Verify that all the modules built correctly. Every module will generate a .lib and .dll file.

Under CMakeTargets, right click on INSTALL and build. This will take some time but not as much as the ALL_BUILD project. This will generate a folder named “install/x64/vc15” with 2 subfolders: “bin” and “lib”.

After this, you are ready to start developing with OpenCV 3.4.1 + CUDA, next post will be a classic “Hello World”.

Lane Detection – Self Driving Car Nanodegree

I started the Self Driving Car Nanodegree in January 2017, I was initially selected for the October 2016 cohort but for personal reasons I couldn’t join then.

So far the Nanodegree complements nicely what I’ve been learning in the Georgia Tech’s OMSCS program, some of the videos used (e.g. Neural Networks) were taken from the Machine Learning class in the OMSCS program.

The first project is to detect lanes in the road, the objective is to get familiar with some basic concepts of Computer Vision (Gaussian filter, Hough Transform, Canny Edge Detection).

This is my final result:

Computational Photography Portfolio

This semester (Fall 2016) in the Georgia Tech OMSCS program, I took Computational Photography. It was a great class!

The final assignment is to make a portfolio to showcase our results from the different assignments we had during the semester.

If you are interested in knowing more about the class, visit the following link: https://cs6475.wordpress.com/fall-2016/

There were 11 assignments:

Assignment # Title Goal
1 A Photograph is a photograph Share one picture to get started with class
2 Image I/O & Python Setup Setup your computing environment
3 Epsilon Photography 2 picture with Epsilon Difference
4 Gradients and Edges Computing with Images
5 Camera Obscura Build a PinHole Camera
6 Blending Experiment with Image Blending
7 Feature Detection Use Feature Detection
8 Panoramas Build a Simple Panorama
9 HDR Experiments with HDR
10 Photos of Space Generate Panorama and PhotoSynths
11 Video Textures Build a Video Texture

Click here to see the Portfolio