Nice discovery: More than Technical

I just find a nice blog, with a lot of good post regarding OpenCV and other cool stuff, tutorials and implementations. The blog has very good explanations and I think it’s worth to look at it.

Without more preamble: More than Technical.

It has a lot of goodies, I already bookmarked it! Probably it would help you as it help me with some issues with OpenCV.

Human nature

The problem with humans is not to aim high and fail, but to aim low and succeed

Just think about it. 💡

I just got it again from Sir Ken  Robinson.

Wake them up!!

I just found this interesting video on how we need a paradigm change on our education systems. Actually, I agree with him in so many levels. I behold how the actual education system doesn’t work and how people fail in it. I saw brilliant people to be failed because the system is corrupt, and because they thought in other ways. The system exploits the creativity and kill the ideas of those who composed it, instead of encourage them and make them grow.

I love one phrase in the video: “wake the students up!, instead of putting them to sleep…“. Nowadays, with so many information we need to be more awake than before. We need to process tons of information, and learn how to discriminate between the good ones from the thrash. The problem is: how the education system wants to put all of us in a production line. They want to produce “educated” people to get some profit. This is not how education should work, education should allow you to free your mind, not to put it in a cage.

Finally, he spoke about “divergent thinking” and how that creativity is destroy as you grow old. I hope that I never forget this one: Do not criticize a child drawing (or any creative activity of his). Do not tell a child how his drawing is bad, nor how his drawing should has this or that. Instead of that just support the creativity and screw the “normal” way of thinking. In the end, can you tell what normal is?

Compiling VXL with VS 2008

I’ve been working the last days with VXL, it is a collection of libraries for computer vision. It includes numeric, imaging, geometry, streaming and more libraries. When one started looking at the code impresses the amount of work people put into it. Also, it has a lot of good features and it is really easy to use, once you know how to compile it and the projects using it.

I struggle a few days trying to compile VXL itself and then linking the projects. Because of that I want to summarize a few tips to do it smoother.

Compiling VXL on Windows

I will describe the Windows steps, but if you are using other OS you can find some info here.

1. First, you need to install
   • Visual Studio with C++
   • Tortoise SVN
   • CMake
2. First create a folder for the VXL libraries. For example, could be “C:\vxl” or whatever you want. Inside that folder create two more:
   • A sources folder “C:\vxl\vxl,” from now on $VXLSRC.
   • A binary folder “C:\vxl\bin,” from now on $VXLBIN.
3. I download VXL from their site, but I have some trouble because the libraries were bugged. Therefore, I suggest you to use the SVN sources. So, lets check out the latest revision.
   • Right click on $VXLSRC, choose the “SVN Checkout” option.
   • In the “URL of repository” box, type in: https://vxl.svn.sourceforge.net/svnroot/vxl/trunk.
   • In the “Checkout directory” box, the folder path $VXLSRC.
   • In the “Checkout depth“, choose “Fully recursive.”
   • In the “Revision” box, choose “Head revision.”
   • Click “OK.”
   • Tortoise SVN should now download the souce code.
4. Now, we need to prepare the Visual Project using CMake. CMake it is a tool that creates all the dependencies and resolve links necessary to build the sources.
   • Open CMake program (from Start menu).
   • In the “Where is the source” box, browse to $VXLSRC.
   • In the “Where to build the binaries” box, browse to $VXLBIN.
   • Click “Configure” (in bottom left of the window).
   • A window will show up, asking for the type of compiler. Choose the version of Visual Studio you’re using. Stay away from “Win64” option for now.
   • CMake will run a whole bunch of tests to determine the settings of the machine, compilers, packages, etc. The progress is shown in bottom of the window. This may take up to several minutes.
   • Once this is done, a window shows up, with a lot of red rows.
   • Scroll to find “BUILD_VGUI.” If it is unchecked,  check it. Click “Configure” again.
   • Scroll to find “VGUI_USE_MFC” (should be in red). If it is unchecked,  check it. Click “Configure.” If you can’t find this option, that means Microsoft Visual Studio was not installed properly. Ask someone.
   • Now the option “Generate” should be active, click it. CMake will now make all the “Projects” and “Solution” files for Microsoft Visual Studio in the $VXLBIN.
   • We finish with CMake for now, you can close it.
5. Compile VXL code
   • Go to $VXLBIN.
   • Double-click on “vxl.sln.” This will open Microsoft Visual Studio.
   • From top menu, View –> Solution Explorer.
   • Right-click on “ALL_BUILD,” click on “Build.” This will build ALL projects in VXL. You can selectively build individual projects by right-click and “Build” that project, if you only need that one.
   • This process can take a while, up to a couple hours, depending on how fast the machine is.
   • After this is done, VXL is ready to use.

Using VXL on a project

Now that we compiled the libraries we can use them in our projects. There are two ways to use them (1) with CMake to create the project or (2) linking the libraries manually.

1. Using CMake for the project. CMake is a tool that creates the projects and solutions for us. It support projects in Visual Studio.
   • First we should create two folders in the project folder. Similar to the steps when compiling VXL with CMake, one for the sources and one for the binaries, from now on I will call them $PRJSRC and $PRJBIN, respectively.
   • Now, we need to create a configuration file to tell CMake all the requirements we need. I will give here a basic one, for more details you can check here.

     # The name of your project. This will be the name of the solution
     PROJECT( test )
     
     # Automatic setting of the VXL libraries
     FIND_PACKAGE(VXL)
     IF(VXL_FOUND)
       INCLUDE(${VXL_CMAKE_DIR}/UseVXL.cmake)
     ENDIF(VXL_FOUND)
     # Another option is to set the path directly:
     #   SET( VXL_DIR D:\vxl\bin )
     
     # Here you tell to CMake which files to include
     IF( VXL_VGUI_FOUND )
       INCLUDE_DIRECTORIES( ${VXL_VGUI_INCLUDE_DIR} )
       SET( test_sources ${test_sources}
         # Put all your source code here: code and headers
         test.cpp
       )
     ENDIF( VXL_VGUI_FOUND )
     
     # Specify the executable to be built
     ADD_EXECUTABLE( test ${test_sources} )
     
     # Specify any other dependent libraries
     IF( VXL_VGUI_FOUND )
       TARGET_LINK_LIBRARIES( test ${VXL_VGUI_LIBRARIES} )
     ENDIF( VXL_VGUI_FOUND )<code>
     

   • Place the configuration file and all your source code in the $PRJSRC folder.
   • Open CMake and put the sources and destination folders to $PRJSRC and $PRJBIN, respectively (The steps are the same as the VXL compilation).
   • Click “Configure” button. The “Generate” button should be active afterward, then click it.
   • Now you can go to $PRJBIN and compile the project.
2. If you don’t want to use CMake or you cannot use it because you have a project already, you need to include the libraries and link them manually.
   • In Visual Studio Tools–>Options, go to the “Projects and Solutions” option.  Then in that tree under “VC++ Directories” change the option “Show directories for:” and choose “Include files.” Then add the paths
     • $VXLSRC\vcl
     • $VXLSRC\core
     • $VXLBIN\vcl
     • $VXLBIN\core
   • Now, in the same place change the option “Show directories for:” to “Library files” and add $VXLBIN\lib
   • If you are using any non-core library you should add them too. For example, if you are using vsol in contrib/gel then you should add $VXLSRC/contrib/gel.
   • Click “OK.”
   • In the Solution Explorer, right-click to your project and choose “Properties.” Go to Configuration Properties–>Linker
   • Under “General,” in the option “Additional Library Directories” add $VXLBIN\lib\Debug
   • Under “Input,” in the option “Additional Dependencies” add vcl.lib, at least. Then link against all the libraries you used or the ones the compiler complains about. For example, if you use $VXLBIN\vil libraries add vil.lib, or if you use $VXLBIN\vil\algo libraries add vil_algo.lib.
   • Click “OK.”

Discovering Image Processing: A Segmentation Application

I hope that this little posts “Discovering Image Processing” (which I will try to write more often) encourage people, from places that don’t know about it (like my country Guatemala), to enter and discover this amazing field.

Yesterday on Steve’s blog I read a great example of what we can do with image processing knowledge and MATLAB.

Actually is quite impressive that with a few commands you can achieve a task like segmenting people out and replacing the background. I hope that people that is not related with the field could find these kind of application interesting enough to give it a try. So, what segmentation is? you could ask; well, is the task of separate one or several objects from the image. For humans is really easy to tell where an object begin and where it ends. For machines, however, this task is not that easy. Therefore, a whole research area is dedicated to solve this problem.

Here they explain how to get from three amigos to two amigos!

Three amigos

Two Amigos

I just discover VUE

I just discover VUE and I love it!…

VUE is a tool to represent ideas, concepts, relations, etc. graphically. It is a great tool to create mind maps. It has one option to incorporate presentations directly from your map. It is an option that I haven’t seen before.

It’s similar to other tools, like free mind, but it allows you to do much more. I’m just exploring the tool, but it looks promising. It even allows you to import ontologies (I’m still strugling to check that option).

I strongly recommend to try the tool. It would change your way to represent ideas. 💡

Sample map I made for represent current trends in Background Modeling to Action Recognition fields.

Background Subtraction

I just found a great compilation of Background Subtraction papers.

• Background Models
  • Basic
  • Statistical
  • Fuzzy
  • Neural Network
  • Background Modeling via Clustering
  • Background Estimation
• Features
  • Color
  • Edge
  • Textures
  • Motion
  • Stereo
• Evaluation Techniques
• Surveys

It has recent papers. It is worth to look at it. 💡