Our Binary World

Hi guys,

Today, I’d like to look at Intel RealSense technology. If you are as lucky as I am, you already have a capable camera. :)

For this tutorial you have to have:

Basic programming skills in a C-based language

Windows 8.1 or higher (64bit)

Camera capable to RealSense® Technology

Visual Studio 2010 and higher

So, let’s begin

Run Visual Studio.Create New Project

a) Expand the C++ tab

b) Choose Win32 Console Application

At the top of the IDE choose the View tab (View->Other Windows->Property Manager) a) Find Other Windows and click on Property Manager

b) New windows should appear on the left side of your screen Here you’ll find two menu items - Debug and Release.

c) Right click on each one and choose  Add Existing Property Sheet.

d) Click Browse and go to C://Program Files (x86)/Intel/RSSDK/props;

There you’ll find 2 files: VS2010-13.Integration.MT.props (for static projects) VS2010-13.Integration.MD.props (for dynamic projects)

Since we are doing a static project, chose the first one.

Now that we’re done with the setup, let’s code.

Include pxcsensemanager.h into your project.

The main class is PXCSenseManager. The class contains all the properties associated with our camera. (In Java, C# and JS all classes contain a specific insert ‘M’ so PXCSenseManager will be PXCMSenseManager there)

To create the manager you have to call the CreateInstance() method, which is within the PXCSenseManager class. It will prepare your environment. If the program cannot create the instance of the class, it will terminate.

// create the PXCSenseManager PXCSenseManager *psm = 0; psm = PXCSenseManager::CreateInstance(); if (!psm) { wprintf_s(L"Unable to create the PXCSenseManager\n"); return 1; }

Now, we have to define what types of stream we would like to enable. We can choose all of them, so let’s do this.

//connect to all lenses/streams of camera //(PXCCapture::StreamType, width=0, height=0, frameRate=0); psm->EnableStream(PXCCapture::STREAM_TYPE_COLOR); psm->EnableStream(PXCCapture::STREAM_TYPE_DEPTH); psm->EnableStream(PXCCapture::STREAM_TYPE_IR);

EnableStream method looks like this.

EnableStream(PXCCapture::StreamType, width=0, height=0, frameRate=0);

as you see it has optional values. Width and Hight is the resolution of the content. If you leave them blank the resolution will be adapted to the best resolution. When we’re done, come back and play with these properties.

Now you have to initialize our manager. It is the last step of this part.

// Manager initializing psm->Init();

If we want to see what the camera sees we have to render frame by frame in a window. Let’s create renderer. The RealSense® SDK supplies libraries that will make our life easier. Instead of working with the Windows API we are able to keep working with Intel’s. Include util_render.h into your project and add the code right after Init() method.

//renderer(L"NAME OF THE WINDOW") UtilRender renderColor(L"color"), renderDepth(L"depth"), renderIR(L"ir");

Now we can read frames from the camera.

while (true) { //trying to get a frame (true - synchronize all streams) //(false - show them as they come) if (psm->AcquireFrame(true) > PXC_STATUS_NO_ERROR) break; //retrieve sample PXCCapture::Sample *sample = psm->QuerySample(); if (sample) { //render frame in the window if (!renderColor.RenderFrame(sample->color)) break; if (!renderDepth.RenderFrame(sample->depth)) break; if (!renderIR.RenderFrame(sample->ir)) break; } psm->ReleaseFrame(); }

Don’t forget to release memory.

Run the program.

Hm, looks unnatural. If you think the same add one string after the init method

// Manager initializing psm->Init(); //natural representation like in a mirror psm->QueryCaptureManager()->QueryDevice()->SetMirrorMode(PXCCapture::Device::MirrorMode::MIRROR_MODE_HORIZONTAL);

Hi folks,

Today, I’d like to discuss a great topic. At least, I think it is.

If you are a decent iOS developer, you know how to implement blocks in Objective-C.

If not, here is an excellent resource, that will show you how they work:

Click

If you're anything like me, you're wondering where this feature came from.

I’m sure you just said, - “Hm, definitely from C”.

…and, it seems that you are probably right. Blocks were introduced by Apple with Mac OS 10.6 and they work in both C and Objective-C. As you will see below, blocks in C have more nasty syntax than Objective-C (yes it can be even worse:)).

I prepared an example for you in pure C. Create an XCode project for Mac OS > Comand line tool > language C, and let’s Rock!

First of all, include

#include Block.h

Let’s create a couple of related structures:

typedef struct{ char *name; int age; }Employee; typedef struct{ char *company_name; Employee **emploee; int counter; void (^add)(Employee *empl); }Company;

As you see, those are pretty simple structs. Except one line. That line is a BLOCK! Hm, looks like an Objective-C block. Exactly! Creating a block variable in C is exactly the same as in Objective-C. Why should you want use blocks? Let’s say you want to encapsulate method implementation inside a method. Blocks are perfect for that

Here we need to create the second part of our project. I use pointers on my structs, so I need to use malloc a lot. Actually, that’s not a bad practice, since I'm going to free memory by the end of the program anyways.

Company *init_company(char *name); Employee *init_empl(char *name, int age); void print(Company *cmp); void release_employees(Company *cmp); int main(int argc, const char * argv[]) { Company *company; company = init_company("Apple"); Employee *alfred = init_empl("Alfred", 25); Employee *max = init_empl("Max", 47); Employee *steven = init_empl("Steven", 31); print(company); release_employees(company); free(company); getchar(); return 0; }

Here are simple initializations of our structs. What if we want to add employees to our company? We could create a method, but I’d like to use blocks because I think this approach is better and it fits the headline of this article:)

In C, instead of calling blocks strictly, we have to call macros Block_copy() - which calls system functions. Add the following code right after the company initialization.

company->add = Block_copy(^(Employee *empl){ company->emploee[company->counter] = empl; ++company->counter; });

Now we can add our employees to the company:

company->add(steven); company->add(max); company->add(alfred);

Ok, now we are almost done. The last step is to release the memory, which is allocated by block:

Block_release(company->add);

Ok, that's it. If you have any questions, post a comment. I'll be around.

Usually, we don't implement algorithms on our own. We are in the habit of using built in functions for sorting, searching, etc. But what about those evil interview questions about binary search or quick sort algorithms? Why do they ask about those things? 

"To show your understanding of computer science," perhaps you would have said. You are probably right. But it's also probably important to understand these algorithms because it makes you a better programmer. 

I learned a lot of this stuff about 3-4 years ago, it was in my university's program. I didn't have very much practical experience in that time. Maybe you are in the same situation.

Recently, I found a great book about Algorithms and I'd like to share my experience. It's about 1 am, and I'm writing this post while a binary search algorithm I'm playing with is trying to find values (text file contains 10_000_000 ints) that do not exist in the array (1_000_000 ints).

The i7 processor in my MacBook pro is working great. I'm really curious about performance in Java and Erlang.

Ok, here is the code. 

If you need the explanation how it works, Google can explain it much better than I probably can. I just wanted to share this pure C code. If you want to test your CPU, here is the link to the files:

Click

largeW.txt 1_000_000 ints

largeT.txt 10_000_000 ints