bool DataBaseEngine::initialize_database() {
#ifndef USE_MYSQL
    QFile db_file(":/assets/" DB_F_NAME);
    const char fname[] = WORK_DIR "/" DB_F_NAME;

#ifdef CLEAN_DB
    QFile(fname).remove();
#endif

    if (db_file.exists() && !(QFile(fname).exists())) {
        QDir().mkdir(WORK_DIR);
        db_file.copy(fname);
        QFile::setPermissions(fname, QFile::WriteOwner | QFile::ReadOwner);
    }

    QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE", DB_NAME);
    db.setDatabaseName(fname);
#else
    QSqlDatabase db = QSqlDatabase::addDatabase("QMYSQL", DB_NAME);
    db.setUserName("user");
    db.setPassword("");
    db.setDatabaseName("face_recognizer");
#endif
    return db.open();
}
Beispiel #2
0
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	DatabaseHandle::Save()
{
	Check_Object(this);

	//
	//--------------------------------------
	// If there were no changes, we are done
	//--------------------------------------
	//
	if (m_readOnly || !m_dirtyFlag)
		return;

	//
	//----------------------------------------------------------------------
	// We will need to adjust pointers as we write this thing out, so make a
	// copy of the database object now
	//----------------------------------------------------------------------
	//
	Database output_db;
	output_db.m_numberOfRecords = m_dataBase->m_numberOfRecords;
	output_db.m_nextRecordID = m_dataBase->m_nextRecordID;

	//
	//----------------------------------------------------
	// Build a table to deal with rethreading the database
	//----------------------------------------------------
	//
	struct OutputRecord
	{
		DWORD
			m_ID,
			m_offset,
			m_nextIDRecord,
			m_nextNameRecord;
		Record
			*m_data;
	};
	OutputRecord *new_records = new OutputRecord[m_dataBase->m_numberOfRecords];
	Check_Pointer(new_records);
	DWORD new_id_index[Database::e_DataBlockSize];
	memset(new_id_index, 0, sizeof(new_id_index));

	//
	//---------------------------------------------------------
	// Start filling in the block information from the database
	//---------------------------------------------------------
	//
	DWORD offset = sizeof(output_db);
	OutputRecord* new_record = new_records;
	for (DWORD i=0; i<Database::e_DataBlockSize; ++i)
	{
		Record* old_record = reinterpret_cast<Record*>(m_dataBase->m_idOffsets[i]);
		if (old_record)
		{
			output_db.m_idOffsets[i] = offset;
			new_id_index[i] = new_record - new_records;
			while (old_record)
			{
				old_record = reinterpret_cast<Record*>((DWORD)old_record + m_baseAddress);
				Check_Object(old_record);

				new_record->m_data = old_record;
				new_record->m_ID = old_record->m_ID;
				new_record->m_offset = offset;
				new_record->m_nextIDRecord = 0;
				new_record->m_nextNameRecord = 0;

				offset +=
					sizeof(*old_record) + old_record->m_length + old_record->m_nameLength;

				old_record = reinterpret_cast<Record*>(old_record->m_nextIDRecord);
				if (old_record)
					new_record->m_nextIDRecord = offset;
				++new_record;
			}
		}
	}

	//
	//-----------------------------------------
	// Make sure Hash index table is up to date
	//-----------------------------------------
	//
	for (i=0; i<Database::e_DataBlockSize; ++i)
	{
		Record* old_record = reinterpret_cast<Record*>(m_dataBase->m_nameOffsets[i]);
		if (old_record)
		{
			old_record = reinterpret_cast<Record*>((DWORD)old_record + m_baseAddress);
			Check_Object(old_record);

			//
			//---------------------------------
			// Find this record in our new data
			//---------------------------------
			//
			DWORD index = old_record->m_ID % Database::e_DataBlockSize;
			int j = new_id_index[index];
			OutputRecord *new_record = &new_records[j];
			for (; j<m_dataBase->m_numberOfRecords; ++j, ++new_record)
			{
				if (new_record->m_ID == old_record->m_ID)
					break;
			}
			Verify(j<m_dataBase->m_numberOfRecords);

			//
			//----------------------
			// Set up the hash chain
			//----------------------
			//
			output_db.m_nameOffsets[i] = new_record->m_offset;
			while (old_record)
			{
				Check_Object(old_record);

				//
				//-----------------------------------------------------------
				// Find the next record, and find where it is in our new data
				//-----------------------------------------------------------
				//
				old_record = reinterpret_cast<Record*>(old_record->m_nextNameRecord);
				Verify(j<m_dataBase->m_numberOfRecords);
				if (old_record)
				{
					old_record = reinterpret_cast<Record*>((DWORD)old_record + m_baseAddress);
					Check_Object(old_record);
					index = old_record->m_ID % Database::e_DataBlockSize;
					j = new_id_index[index];
					OutputRecord *next_record = &new_records[j];
					for (; j<m_dataBase->m_numberOfRecords; ++j, ++next_record)
					{
						if (next_record->m_ID == old_record->m_ID)
							break;
					}
					Verify(j<m_dataBase->m_numberOfRecords);
					new_record->m_nextNameRecord = next_record->m_offset;
					new_record = next_record;
				}
			}
		}
	}

	//
	//------------------------------------------------
	// This file was read/write, so write it out again
	//------------------------------------------------
	//
	FileStream db_file(m_fileName, FileStream::WriteOnly);
	db_file.WriteBytes(&output_db, sizeof(output_db));

	//
	//----------------------
	// Write out each record
	//----------------------
	//
	new_record=new_records;
	for (i=0; i<m_dataBase->m_numberOfRecords; ++i, ++new_record)
	{
		Record* old_record = new_record->m_data;

		//
		//------------------------------------------------------------
		// Save the old connection info, then replace it with the data
		// calculated in the new records
		//------------------------------------------------------------
		//
		bool free_block = old_record->m_mustFree;
		DWORD next_id = old_record->m_nextIDRecord;
		DWORD next_name = old_record->m_nextNameRecord;
		old_record->m_mustFree = false;
		old_record->m_nextIDRecord = new_record->m_nextIDRecord;
		old_record->m_nextNameRecord = new_record->m_nextNameRecord;

		//
		//------------------------------------------
		// Write out the info, then restore the data
		//------------------------------------------
		//
		db_file.WriteBytes(
			old_record,
			sizeof(*old_record) + old_record->m_length + old_record->m_nameLength
		);
		old_record->m_mustFree = free_block;
		old_record->m_nextIDRecord = next_id;
		old_record->m_nextNameRecord = next_name;
	}

	//
	//---------
	// Clean up
	//---------
	//
	delete[] new_records;
	m_dirtyFlag = false;
}
Beispiel #3
0
int Database::ReadFile(int file_num)
{
    printf("*--------------Database Read-----------------*\n");
    std::string dir = MACHINEPATH;
    dir.append("Database/Corpus/");
    std::string suffix = ".txt";
    char buf[10]; 
    sprintf(buf, "%d", file_num);
    
    std::ifstream database_setup;
    printf("Reading database setup file...\n");
    std::string db_file(dir);
    db_file.append("database_summary_");
    db_file.append(buf);
    db_file.append(suffix);
    database_setup.open(db_file.c_str());
    database_setup >> mfcc_num_coef;
    database_setup >> fft_frame_length;
    fft_frame_length += 2;
    database_setup >> database_frame_num;
    database_setup >> num_tracks;
    database_setup.close();
    printf("Complete\n");

    std::ifstream mfccFile;
    printf("Reading mfcc file...\n");
    std::string mf_file(dir);
    mf_file.append("mfcc_frames_");
    mf_file.append(buf);
    mf_file.append(suffix);
    mfccFile.open(mf_file);
    mfcc_matrix = (double**)malloc(sizeof(double*)*database_frame_num);
    for(int i = 0; i < database_frame_num; i++){
        mfcc_matrix[i] = (double*)malloc(sizeof(double)*mfcc_num_coef);
        for(int j = 0 ; j < mfcc_num_coef;j++){
            mfccFile >> mfcc_matrix[i][j];
        }
    }
    mfccFile.close();
    printf("Complete\n");
    
    std::ifstream fftFile;
    printf("Reading fft frames file...\n");
    std::string ft_file(dir);
    ft_file.append("fft_frames_");
    ft_file.append(buf);
    ft_file.append(suffix);
    fftFile.open(ft_file);
    fft_matrix = (double**)malloc(sizeof(double*)*database_frame_num);
    for(int i = 0 ; i < database_frame_num; i++){
        fft_matrix[i] = (double*)malloc(sizeof(double)*fft_frame_length);
        for(int j = 0; j < fft_frame_length; j++){
            fftFile >> fft_matrix[i][j];
        }
    }

    fftFile.close();
    printf("Complete\n");
    
    debug_print(("Reading track frame lengths..."));
    std::string track_frame_l_file(MACHINEPATH);
    track_frame_l_file.append("Database/Corpus/track_frame_lengths.txt");
    std::ifstream tr_frm_l_file;
    tr_frm_l_file.open(track_frame_l_file);
    track_frame_length = (int*)malloc(sizeof(int)*num_tracks);
    for(int i = 0 ; i < num_tracks; i++){
        tr_frm_l_file >> track_frame_length[i];
    }
    tr_frm_l_file.close();
    debug_print(("\tComplete\n"));
    
    debug_print(("Reading buf lengths..."));
    std::string buf_s_file_p(MACHINEPATH);
    buf_s_file_p.append("Database/Corpus/buffer_sizes.txt");
    std::ifstream buf_s_file;
    buf_s_file.open(buf_s_file_p);
    track_buffer_sizes = (long*)malloc(sizeof(long)*num_tracks);
    for(int i = 0 ; i < num_tracks; i++){
        buf_s_file >> track_buffer_sizes[i];
    }
    buf_s_file.close();
    debug_print(("\tComplete\n"));
    debug_print(("Number MFCC Coefficients     : %d\n",mfcc_num_coef));
    debug_print(("Number values p FFT frame    : %d\n",fft_frame_length));
    debug_print(("Total num frames in database : %ld\n\n",database_frame_num));
    printf("*--------------------------------------------*\n");

    gr_size = (int)database_frame_num;
    gr_coef = mfcc_num_coef;
    gr_fft = fft_frame_length;
    return 0;
}
Beispiel #4
0
int Database::ReadFileGroup(int file_num,int s_grouping,int type)
{
    grouping = s_grouping;
    
    // grouping must be > 0
    printf("\n*--------------Database Group Read-----------------*\n");

    std::string dir = MACHINEPATH;
    switch(type){
        case 0: dir.append("Database/Corpus/"); break;
        case 1: dir.append("Database/Corpus/DB/"); break;
    }
    //dir.append("Database/Corpus/");
    std::string suffix = ".txt";
    char buf[10]; // enough to hold all numbers up to 64-bits
    sprintf(buf, "%d", file_num);
    
    std::ifstream database_setup;
    printf("Reading database setup file...");
    std::string db_file(dir);
    db_file.append("database_summary_");
    db_file.append(buf);
    db_file.append(suffix);
    database_setup.open(db_file.c_str());
    database_setup >> mfcc_num_coef;
    database_setup >> fft_frame_length;
    fft_frame_length += 2;
    database_setup >> database_frame_num;
    database_setup >> num_tracks;
    database_setup.close();
    printf("\tComplete\n");
    
    std::ifstream mfccFile;
    printf("Reading mfcc file...");
    std::string mf_file(dir);
    mf_file.append("mfcc_frames_");
    mf_file.append(buf);
    mf_file.append(suffix);
    mfccFile.open(mf_file);
    
    grouped_size = (long)floor(database_frame_num/grouping);
    int grouped_coef = mfcc_num_coef * grouping;    
    gr_size = (int)grouped_size;
    gr_coef = grouped_coef;

    mfcc_matrix = (double**)malloc(sizeof(double*)*grouped_size);
    for(int i = 0; i < grouped_size; i++){
        mfcc_matrix[i] = (double*)malloc(sizeof(double)*grouped_coef);
    }
    for(int i = 0; i < grouped_size  ; i++){
        for(int j = 0 ; j < grouped_coef;j++){
            mfccFile >> mfcc_matrix[i][j];
        }
    }
    mfccFile.close();
    printf("\tComplete\n");
    
    std::ifstream fftFile;
    printf("Reading fft frames file...");
    std::string ft_file(dir);
    ft_file.append("fft_frames_");
    ft_file.append(buf);
    ft_file.append(suffix);
    fftFile.open(ft_file);
    fft_length_grouped = fft_frame_length * grouping;
    printf("fft len group : %d\n",fft_length_grouped);
    fft_matrix = (double**)malloc(sizeof(double*)*grouped_size);
    for(int i = 0 ; i < grouped_size; i++){
        fft_matrix[i] = (double*)malloc(sizeof(double)*fft_length_grouped);
    }
    for(int i = 0 ; i < grouped_size; i++){
        for(int j = 0; j < fft_length_grouped; j++){
            fftFile >> fft_matrix[i][j];
           // printf("%f ",fft_matrix[i][j]);
        }
    }
    fftFile.close();
    printf("\tComplete\n");
    
    gr_size = (int)grouped_size;
    gr_fft = fft_length_grouped;
    debug_print(("Reading track frame lengths..."));
    std::string track_frame_l_file(dir);
    track_frame_l_file.append("track_frame_lengths.txt");
    std::ifstream tr_frm_l_file;
    tr_frm_l_file.open(track_frame_l_file);
    track_frame_length = (int*)malloc(sizeof(int)*num_tracks);
    for(int i = 0 ; i < num_tracks; i++){
        tr_frm_l_file >> track_frame_length[i];
        printf("Track Length : %d \n",track_frame_length[i]);
    }
    tr_frm_l_file.close();
    
    debug_print(("Reading buf lengths..."));
    std::string buf_s_file_p(dir);
    buf_s_file_p.append("buffer_sizes.txt");
    std::ifstream buf_s_file;
    buf_s_file.open(buf_s_file_p);
    track_buffer_sizes = (long*)malloc(sizeof(long)*num_tracks);
    for(int i = 0 ; i < num_tracks; i++){
        buf_s_file >> track_buffer_sizes[i];
    }
    buf_s_file.close();
    debug_print(("\tComplete\n"));

    
    debug_print(("\tComplete\n"));
    printf("Num Tracks : %d\n",num_tracks);
    debug_print(("Number MFCC Coefficients     : %d\n",mfcc_num_coef));
    debug_print(("Number values p FFT frame    : %d\n",fft_frame_length));
    debug_print(("Total num frames in database : %ld\n",database_frame_num));
    debug_print(("Grouped MFCC num coefs       : %d\n",grouped_coef));
    debug_print(("Num frames when grouped      : %ld\n",grouped_size));
    GroupTrackLengths();
    printf("*--------------------------------------------------*\n");

    return 0;
}
Beispiel #5
0
int main(int argc, char *argv[])
{
    QCoreApplication app(argc,argv);

    // check input args
    QStringList inputArgs = app.arguments();
    if(inputArgs.size() != 2)   {
        badInput();
        return -1;
    }

    // open osmscout map
    osmscout::DatabaseParameter map_param;
    osmscout::Database map(map_param);
    if(!map.Open(inputArgs[1].toStdString()))   {
        qDebug() << "ERROR: Failed to open osmscout map";
        return -1;
    }
    osmscout::TypeConfig * typeConfig = map.GetTypeConfig();
    osmscout::TypeSet typeSet;
    setTypesForAdminRegions(typeConfig,typeSet);

//    GeoBoundingBox tempbbox;
//    tempbbox.minLon = -83.3203; tempbbox.maxLon = -82.9688;
//    tempbbox.minLat = 42.1875; tempbbox.maxLat = 42.3633;

////    tempbbox.minLon -= 1; tempbbox.maxLon += 1;
////    tempbbox.minLat -= 1; tempbbox.maxLat += 1;

    // create search database
    Kompex::SQLiteDatabase * database;
    Kompex::SQLiteStatement * stmt;

    QString db_file_path = app.applicationDirPath()+"/searchdb.sqlite";
    QFile db_file(db_file_path);
    if(db_file.exists())   {
        if(!db_file.remove())   {
            qDebug() << "ERROR: searchdb.sqlite exists and "
                        "could not be deleted";
            return -1;
        }
    }

    try   {
        database = new Kompex::SQLiteDatabase("searchdb.sqlite",
                                              SQLITE_OPEN_READWRITE |
                                              SQLITE_OPEN_CREATE,0);

        stmt = new Kompex::SQLiteStatement(database);

        stmt->SqlStatement("CREATE TABLE name_lookup("
                           "name_id INTEGER PRIMARY KEY NOT NULL,"
                           "name_lookup TEXT NOT NULL UNIQUE);");

        stmt->SqlStatement("CREATE TABLE admin_regions("
                           "id INTEGER PRIMARY KEY NOT NULL,"
                           "node_offsets BLOB,"
                           "way_offsets BLOB,"
                           "area_offsets BLOB"
                           ");");

        stmt->SqlStatement("CREATE TABLE streets("
                           "id INTEGER PRIMARY KEY NOT NULL,"
                           "node_offsets BLOB,"
                           "way_offsets BLOB,"
                           "area_offsets BLOB"
                           ");");

        stmt->SqlStatement("CREATE TABLE pois("
                           "id INTEGER PRIMARY KEY NOT NULL,"
                           "node_offsets BLOB,"
                           "way_offsets BLOB,"
                           "area_offsets BLOB"
                           ");");
    }
    catch(Kompex::SQLiteException &exception)   {
        qDebug() << "ERROR: SQLite exception creating database:"
                 << QString::fromStdString(exception.GetString());
        return -1;
    }


    // build a tile list for the dataset

//    // world bbox
//    GeoBoundingBox bbox_world;
//    bbox_world.minLon = -180.0; bbox_world.maxLon = 180.0;
//    bbox_world.minLat = -90.0;  bbox_world.maxLat = 90.0;

    // map data bbox
    GeoBoundingBox bbox_map;
    map.GetBoundingBox(bbox_map.minLat,bbox_map.minLon,
                       bbox_map.maxLat,bbox_map.maxLon);

    // generate tile list
    std::vector<Tile*> list_tiles;
    buildTileList(bbox_map,list_tiles);

#ifdef DEBUG_WITH_OSG
    return displayTiles(bbox_map,list_tiles);
#endif


    // [name_id] [name_key]
    int32_t name_id=1;
    boost::unordered_map<std::string,int32_t> table_names;

    // build database tables
    bool opOk=false;

    // admin_regions
    qDebug() << "INFO: Building admin_regions table...";
    setTypesForAdminRegions(typeConfig,typeSet);
    opOk = buildTable(stmt,name_id,table_names,"admin_regions",
                      list_tiles,map,typeSet,false,true,true);
    if(opOk)   {
        qDebug() << "INFO: Finished building admin_regions table";
    }
    else   {
        qDebug() << "ERROR: Failed to build admin_regions table";
        return -1;
    }

    // streets
    qDebug() << "INFO: Building streets table...";
    setTypesForStreets(typeConfig,typeSet);
    opOk = buildTable(stmt,name_id,table_names,"streets",
                      list_tiles,map,typeSet,false,false,false);
    if(opOk)   {
        qDebug() << "INFO: Finished building streets table";
    }
    else   {
        qDebug() << "ERROR: Failed to build streets table";
        return -1;
    }

    // pois
    qDebug() << "INFO: Building pois table...";
    setTypesForPOIs(typeConfig,typeSet);
    opOk = buildTable(stmt,name_id,table_names,"pois",
                      list_tiles,map,typeSet,false,false,false);
    if(opOk)   {
        qDebug() << "INFO: Finished building pois table";
    }
    else   {
        qDebug() << "ERROR: Failed to build pois table";
        return -1;
    }

    // build name_lookup table
    qDebug() << "INFO: Building name_lookup table...";
    opOk = buildNameLookupTable(stmt,table_names);
    if(opOk)   {
        qDebug() << "INFO: Finished building name_lookup table";
    }
    else   {
        qDebug() << "ERROR: Failed to build name_lookup table";
        return -1;
    }

    // vacuum to minimize db
    try   {
        stmt->SqlStatement("VACUUM;");
    }
    catch(Kompex::SQLiteException &exception)   {
        qDebug() << "ERROR: SQLite exception vacuuming:"
                 << QString::fromStdString(exception.GetString());
        return -1;
    }

    // clean up
    for(size_t i=0; i < list_tiles.size(); i++)   {
        delete list_tiles[i];
    }
    list_tiles.clear();
    delete stmt;
    delete database;

//    // ### debug
//    std::map<int64_t,std::string> table_count_names;
//    boost::unordered_map<std::string,qint64>::iterator it;
//    for(it = table_names.begin(); it != table_names.end(); ++it)   {
//        std::map<int64_t,int64_t>::iterator d_it;
//        d_it = g_table_nameid_count.find(it->second);

//        std::pair<int64_t,std::string> data;
//        data.first = d_it->second;
//        data.second = it->first;
//        table_count_names.insert(data);
//    }

//    std::map<int64_t,std::string>::iterator c_it;
//    for(c_it  = table_count_names.begin();
//        c_it != table_count_names.end(); ++c_it)   {
//        qDebug() << QString::fromStdString(c_it->second) << ":" << c_it->first;
//    }

//    // debug
//    boost::unordered_map<std::string,qint64>::iterator it;
//    for(it  = table_names.begin(); it != table_names.end(); ++it)
//    {
//        qDebug() << it->second << ": " << QString::fromStdString(it->first);
//    }
}