savetofile.cpp

SIFT的c++实现

/*******************************************************************************
 *
 * FILENAME:     saveToFile.cpp
 * DESCRIPTION:  save to file
 *
 * AUTHOR:       Jun Liu ([e-mail])
 * INSTITUTION:  Advanced Interfaces Group,
 *               Department of Computer Science,
 *               the University of Manchester, United Kingdom
 * DATE:         September 2006
 *
 *******************************************************************************/

#include "saveToFile.h"
#include <fstream>
#include <iostream>
#include <vil/vil_save.h>

bool saveDescriptorsToFile(vector<Descriptor> const& descs, const char*filename)
{
    ofstream file (filename);
    if (!file.is_open())
    {
        cerr << "Error opening file " << filename << endl;
        return false;
    }

    file.precision(15);

    int size = descs.size();
    int dim  = descs[0].fv.size();
    file << size << " " << dim << endl;

    for (int i=0; i<size; ++i)
    {
        file << descs[i].xi << " " << descs[i].yi;
        for (int j=0; j<dim; ++j)
            file << " " << descs[i].fv[j];
        file << endl;
    }
    
    file.close();
    return true;
}



void draw(int x, int y,  vil_image_view<vxl_byte> & img)
{
    int width  = img.ni();
    int height = img.nj();
    
    if (x >=0    &&
        y >=0    &&
        x <width &&
        y <height)
    {
        img(x,y,0) = 0;
        img(x,y,1) = 255;
        img(x,y,2) = 0;
    }
}


void drawLine(int x, int y, int offsetx, int offsety, vil_image_view<vxl_byte> & img)
{
    if (abs(offsety) ==0 && abs(offsety) == 0)
        return;

    if (abs(offsetx) > abs(offsety))
    {
        int steps = abs(offsetx);
        float slope = static_cast<float>(offsety) / static_cast<float>(offsetx);
        
        for (int i=0; i<steps; ++i)
        {
            int xx = x + abs(offsetx) / offsetx * i;
            int yy = static_cast<int>(slope*i) + y;
            draw(xx,yy,img);
        }
    }
    else
    {
        int steps = abs(offsety);
        float slope = static_cast<float>(offsetx) / static_cast<float>(offsety);
        
        for (int i=0; i<steps; ++i)
        {
            int yy = y + (abs(offsety) / offsety) * i;
            int xx = static_cast<int>(slope*i) + x;
            draw(xx,yy,img);
        }
    }
}


bool saveFeaturesToImages(vector<Keypoint> const& kps,
                          vil_image_view<vxl_byte> const& src,
                          const char* filename)
{

    vil_image_view<vxl_byte> dst (src);
    
    
    int size = kps.size();

    for (int i=0; i<size; ++i)
    {
        int x = static_cast<int>(kps[i].xi);
        int y = static_cast<int>(kps[i].yi);
        
        draw(x,y,dst);

        const vector <double>& maglist   = kps[i].mag;
        const vector <double>& orienlist = kps[i].orien;
        

        for (unsigned int j=0; j< maglist.size(); j++)
        {
            double mag = maglist[j];
            double orien = orienlist[j];

            double length = mag * dst.ni() / 100.0;
            
            int offsetx = static_cast<int>(length * cos(orien));
            int offsety = static_cast<int>(length * sin(orien));

            drawLine(x,y,offsetx,offsety, dst);
        }
    }
    
    vil_save(dst,filename);
    return true;

}