void CentralRegression::CalculateRegressionFunction(vector<RegressionPts>
&calib_matches)
{
Clear();
RemoveOutliersAndCopy(calib_matches);
// First step here is to find the boundaries (min, max in x, y domains).
CalculateMinMax();
if (mdouble_min_y == mdouble_max_y)
// constant answers
{
for (int x_section = 0; x_section < mint_num_x_bins; x_section++)
{
mmap_alignment_function.insert(pair<int,int>(x_section,0));
}
return;
}
CalculateSectionsStd();
CalculateScoreMatrix();
//PrintScoreMatrix("c:\\score_matrix.csv");
CalculateAlignmentMatrix();
//PrintAlignmentScoreMatrix("c:\\alignment_matrix.csv");
CalculateRegressionFunction();
//PrintRegressionFunction("c:\\mass_align_func.csv");
}
//! Iterate over the model and calculate its overall dimensions
void CAssParser::CalculateMinMax(S3DModelPiece* piece)
{
piece->goffset = piece->parent ? piece->parent->goffset + piece->offset : piece->offset;
//! update model min/max extents
piece->model->mins.x = std::min(piece->goffset.x + piece->mins.x, piece->model->mins.x);
piece->model->mins.y = std::min(piece->goffset.y + piece->mins.y, piece->model->mins.y);
piece->model->mins.z = std::min(piece->goffset.z + piece->mins.z, piece->model->mins.z);
piece->model->maxs.x = std::max(piece->goffset.x + piece->maxs.x, piece->model->maxs.x);
piece->model->maxs.y = std::max(piece->goffset.y + piece->maxs.y, piece->model->maxs.y);
piece->model->maxs.z = std::max(piece->goffset.z + piece->maxs.z, piece->model->maxs.z);
//! Repeat with childs
for (unsigned int i = 0; i < piece->childs.size(); i++) {
CalculateMinMax(piece->childs[i]);
}
}
S3DModel* CAssParser::Load(const std::string& modelFilePath)
{
LOG_S(LOG_SECTION_MODEL, "Loading model: %s", modelFilePath.c_str() );
const std::string modelPath = FileSystem::GetDirectory(modelFilePath);
const std::string modelName = FileSystem::GetBasename(modelFilePath);
//! LOAD METADATA
//! Load the lua metafile. This contains properties unique to Spring models and must return a table
std::string metaFileName = modelFilePath + ".lua";
if (!CFileHandler::FileExists(metaFileName, SPRING_VFS_ZIP)) {
//! Try again without the model file extension
metaFileName = modelPath + '/' + modelName + ".lua";
}
LuaParser metaFileParser(metaFileName, SPRING_VFS_MOD_BASE, SPRING_VFS_ZIP);
if (!CFileHandler::FileExists(metaFileName, SPRING_VFS_ZIP)) {
LOG_S(LOG_SECTION_MODEL, "No meta-file '%s'. Using defaults.", metaFileName.c_str());
} else if (!metaFileParser.Execute()) {
LOG_SL(LOG_SECTION_MODEL, L_ERROR, "'%s': %s. Using defaults.", metaFileName.c_str(), metaFileParser.GetErrorLog().c_str());
}
//! Get the (root-level) model table
const LuaTable& metaTable = metaFileParser.GetRoot();
if (metaTable.IsValid()) {
LOG_S(LOG_SECTION_MODEL, "Found valid model metadata in '%s'", metaFileName.c_str());
}
//! LOAD MODEL DATA
//! Create a model importer instance
Assimp::Importer importer;
//! Create a logger for debugging model loading issues
Assimp::DefaultLogger::create("",Assimp::Logger::VERBOSE);
const unsigned int severity = Assimp::Logger::Debugging|Assimp::Logger::Info|Assimp::Logger::Err|Assimp::Logger::Warn;
Assimp::DefaultLogger::get()->attachStream( new AssLogStream(), severity );
//! Give the importer an IO class that handles Spring's VFS
importer.SetIOHandler( new AssVFSSystem() );
//! Speed-up processing by skipping things we don't need
importer.SetPropertyInteger(AI_CONFIG_PP_RVC_FLAGS, aiComponent_CAMERAS|aiComponent_LIGHTS|aiComponent_TEXTURES|aiComponent_ANIMATIONS);
#ifndef BITMAP_NO_OPENGL
//! Optimize VBO-Mesh sizes/ranges
GLint maxIndices = 1024;
GLint maxVertices = 1024;
glGetIntegerv(GL_MAX_ELEMENTS_INDICES, &maxIndices);
glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, &maxVertices); //FIXME returns not optimal data, at best compute it ourself! (pre-TL cache size!)
importer.SetPropertyInteger(AI_CONFIG_PP_SLM_VERTEX_LIMIT, maxVertices);
importer.SetPropertyInteger(AI_CONFIG_PP_SLM_TRIANGLE_LIMIT, maxIndices/3);
#endif
//! Read the model file to build a scene object
LOG_S(LOG_SECTION_MODEL, "Importing model file: %s", modelFilePath.c_str() );
const aiScene* scene = importer.ReadFile( modelFilePath, ASS_POSTPROCESS_OPTIONS );
if (scene != NULL) {
LOG_S(LOG_SECTION_MODEL,
"Processing scene for model: %s (%d meshes / %d materials / %d textures)",
modelFilePath.c_str(), scene->mNumMeshes, scene->mNumMaterials,
scene->mNumTextures );
} else {
LOG_SL(LOG_SECTION_MODEL, L_ERROR, "Model Import: %s",
importer.GetErrorString());
}
SAssModel* model = new SAssModel;
model->name = modelFilePath;
model->type = MODELTYPE_ASS;
model->scene = scene;
//model->meta = &metaTable;
//! Gather per mesh info
CalculatePerMeshMinMax(model);
//! Assign textures
//! The S3O texture handler uses two textures.
//! The first contains diffuse color (RGB) and teamcolor (A)
//! The second contains glow (R), reflectivity (G) and 1-bit Alpha (A).
if (metaTable.KeyExists("tex1")) {
model->tex1 = metaTable.GetString("tex1", "default.png");
} else {
//! Search for a texture
std::vector<std::string> files = CFileHandler::FindFiles("unittextures/", modelName + ".*");
for(std::vector<std::string>::iterator fi = files.begin(); fi != files.end(); ++fi) {
model->tex1 = FileSystem::GetFilename(*fi);
break; //! there can be only one!
}
}
if (metaTable.KeyExists("tex2")) {
model->tex2 = metaTable.GetString("tex2", "");
} else {
//! Search for a texture
std::vector<std::string> files = CFileHandler::FindFiles("unittextures/", modelName + "2.*");
for(std::vector<std::string>::iterator fi = files.begin(); fi != files.end(); ++fi) {
model->tex2 = FileSystem::GetFilename(*fi);
break; //! there can be only one!
}
}
model->flipTexY = metaTable.GetBool("fliptextures", true); //! Flip texture upside down
model->invertTexAlpha = metaTable.GetBool("invertteamcolor", true); //! Reverse teamcolor levels
//! Load textures
LOG_S(LOG_SECTION_MODEL, "Loading textures. Tex1: '%s' Tex2: '%s'",
model->tex1.c_str(), model->tex2.c_str());
texturehandlerS3O->LoadS3OTexture(model);
//! Load all pieces in the model
LOG_S(LOG_SECTION_MODEL, "Loading pieces from root node '%s'",
scene->mRootNode->mName.data);
LoadPiece(model, scene->mRootNode, metaTable);
//! Update piece hierarchy based on metadata
BuildPieceHierarchy( model );
//! Simplified dimensions used for rough calculations
model->radius = metaTable.GetFloat("radius", model->radius);
model->height = metaTable.GetFloat("height", model->height);
model->relMidPos = metaTable.GetFloat3("midpos", model->relMidPos);
model->mins = metaTable.GetFloat3("mins", model->mins);
model->maxs = metaTable.GetFloat3("maxs", model->maxs);
//! Calculate model dimensions if not set
if (!metaTable.KeyExists("mins") || !metaTable.KeyExists("maxs")) CalculateMinMax( model->rootPiece );
if (model->radius < 0.0001f) CalculateRadius( model );
if (model->height < 0.0001f) CalculateHeight( model );
//! Verbose logging of model properties
LOG_SL(LOG_SECTION_MODEL, L_DEBUG, "model->name: %s", model->name.c_str());
LOG_SL(LOG_SECTION_MODEL, L_DEBUG, "model->numobjects: %d", model->numPieces);
LOG_SL(LOG_SECTION_MODEL, L_DEBUG, "model->radius: %f", model->radius);
LOG_SL(LOG_SECTION_MODEL, L_DEBUG, "model->height: %f", model->height);
LOG_SL(LOG_SECTION_MODEL, L_DEBUG, "model->mins: (%f,%f,%f)", model->mins[0], model->mins[1], model->mins[2]);
LOG_SL(LOG_SECTION_MODEL, L_DEBUG, "model->maxs: (%f,%f,%f)", model->maxs[0], model->maxs[1], model->maxs[2]);
LOG_S(LOG_SECTION_MODEL, "Model %s Imported.", model->name.c_str());
return model;
}
