vlfeat | An open library of computer vision algorithms | Computer Vision library

First, you need to obtain a dictionary of visual words, or to be more specific: cluster the SIFT features of all images using k-means clustering. In [1], a coarse clustering using e.g. 64, or 256 clusters is recommended.

For that, we have to concatenate all descriptors into one matrix, which we can then pass to the vl_kmeans function. Further, we convert the descriptors from uint8 to single, as the vl_kmeans function requires the input to be either single or double.

IMO autotools is way overkill for this.

You can do this quite easily. However there are some odd things about your makefile.

Most importantly, all your files are suffixed with a .c extension which means they are C files, but you are compiling them with g++ which is a C++ compiler. This does not make sense. Either you should be naming your source files as C++ files, which means either .cc or .cxx or .cpp or similar, or you should be using a C compiler like gcc not g++.

I will assume your code is C code based on the file extensions.

Please use standard variables (CC, CPPFLAGS, CFLAGS, LDLIBS):

Basically if you specify any weights which is not imagenet, it will just use keras model.load_weights to load it and I guess image-vgg-m-2408.mat is not a valid one that keras can load directly here.

https://github.com/keras-team/keras-applications/blob/master/keras_applications/vgg16.py#L197

This issue occured because of the version of keras.

In my case, I was downgrade keras 2.2.2 to 2.2.0, and the problem was solved.

Tested recently on cuda 9.0, tensorflow 1.9 and pytorch 0.4.1, the differences are now negligible for the same operations.

See the proper timing here.

I was able to make this work. It was a stupid thing I was ignoring.

Neither of those two methods you mentioned achieve what you want do. The answer depends on the object in your pictures. If it has mostly flat faces, then you can rely on estimating the homography, see this tutorial.

If that's not case then can use the epipolar constraint to remove outliers / get geometrically consistent matches, see this tutorial. There are some other ways to achieve this if the speed is of importance in your application.

I got over this hurdle with tf.reshape(...) (instead of calling weights['wc1'].reshape(...) ). I am still not certain about the performance yet, or if this is a horribly naive endeavor.

UPDATE Further testing, this approach appears to be possible at least functionally (as in I have created a TensorFlow CNN model that will run and produce predictions that appear consistent with MatConvNet model. I make no claims on accuracies between the two).

I am sharing my code. In my case, it was a very small network - and if you are attempting to use this code for your own matconvnet to tensorflow project, you will likely need much more modifications: https://github.com/melissadale/MatConv2TensorFlow

I think your main problems here are significant difference in lighting between the images, and specular reflections off the plastic casing. You are also looking at the inside of the USB drive through the transparent plastic, which doesn't help.

What feature detectors/descriptors have you tried? I would start with SURF, and then I would try MSER. It is also possible to use multiple detectors and descriptors, but you should be careful to keep them separate. Of course, there are also lots of parameters for you to tune.

Another thing that may be helpful is to take higher-resolution images.

If you are trying to do 3D reconstruction, can you assume that the camera does not move much between the images? In that case, try using vision.PointTracker to track points from one frame into the other instead of matching them.