void CalculateMVCoord(QVector<QPoint> *boundary, MvcPerporties *mvc, QVector<QPoint> *Coordinates)
{
int BoundarySize = mvc->BoundarySize;
double *mvcArray = mvc->mvcArray;
double *weightArray = new double[BoundarySize];
int vertexSize = Coordinates->size();
for (int i = 0; i < vertexSize; ++i)
{
double sum = CalculateWeights(QPointF(Coordinates->at(i)), boundary, weightArray);
for (int j = 0; j < BoundarySize; ++j)
*(mvcArray + i * BoundarySize + j) = weightArray[j] / sum;
}
delete[] weightArray;
}
void Point2PhantomNode::MakeResult(vector<FeatureGraphNode> & res, size_t maxCount)
{
vector<OsrmMappingTypes::FtSeg> segments;
sort(m_candidates.begin(), m_candidates.end(), [](Candidate const & r1, Candidate const & r2)
{
return (r1.m_dist < r2.m_dist);
});
size_t const n = min(m_candidates.size(), maxCount);
segments.resize(n);
for (size_t j = 0; j < n; ++j)
{
OsrmMappingTypes::FtSeg & seg = segments[j];
Candidate const & c = m_candidates[j];
seg.m_fid = c.m_fid;
seg.m_pointStart = c.m_segIdx;
seg.m_pointEnd = c.m_segIdx + 1;
}
OsrmFtSegMapping::OsrmNodesT nodes;
m_routingMapping.m_segMapping.GetOsrmNodes(segments, nodes);
res.clear();
res.resize(maxCount);
for (size_t j = 0; j < maxCount; ++j)
{
if (!segments[j].IsValid())
continue;
auto it = nodes.find(segments[j].Store());
if (it == nodes.cend())
continue;
FeatureGraphNode & node = res[j];
if (!m_direction.IsAlmostZero())
{
// Filter income nodes by direction mode
OsrmMappingTypes::FtSeg const & node_seg = segments[j];
FeatureType feature;
Index::FeaturesLoaderGuard loader(m_index, m_routingMapping.GetMwmId());
loader.GetFeatureByIndex(node_seg.m_fid, feature);
feature.ParseGeometry(FeatureType::BEST_GEOMETRY);
m2::PointD const featureDirection = feature.GetPoint(node_seg.m_pointEnd) - feature.GetPoint(node_seg.m_pointStart);
bool const sameDirection = (m2::DotProduct(featureDirection, m_direction) > 0);
if (sameDirection)
{
node.node.forward_node_id = it->second.first;
node.node.reverse_node_id = INVALID_NODE_ID;
}
else
{
node.node.forward_node_id = INVALID_NODE_ID;
node.node.reverse_node_id = it->second.second;
}
}
else
{
node.node.forward_node_id = it->second.first;
node.node.reverse_node_id = it->second.second;
}
node.segment = segments[j];
node.segmentPoint = m_candidates[j].m_point;
node.mwmId = m_routingMapping.GetMwmId();
CalculateWeights(node);
}
res.erase(remove_if(res.begin(), res.end(),
[](FeatureGraphNode const & f)
{
return !f.mwmId.IsAlive();
}),
res.end());
}
//! Loads and returns a skinned model from a file.
SkinnedModel* ModelImporter::LoadSkinnedModel(string filename)
{
// Is the model already loaded?
if(mSkinnedModelMap.find(filename) != mSkinnedModelMap.end())
return mSkinnedModelMap[filename];
Assimp::Importer importer;
mFilename = filename;
SkinnedModel* model = NULL;
// Important! Makes sure that if the angle between two face normals is > 80 they are not smoothed together.
// Since the angle between a cubes face normals is 90 the lighting looks very bad if we don't specify this.
importer.SetPropertyFloat(AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE, 80.0f);
importer.SetPropertyInteger(AI_CONFIG_IMPORT_TER_MAKE_UVS, 1);
importer.SetPropertyInteger(AI_CONFIG_PP_SBP_REMOVE, aiPrimitiveType_LINE);
// Load scene from the file.
const aiScene* scene = importer.ReadFile(filename,
aiProcess_CalcTangentSpace |
aiProcess_Triangulate |
aiProcess_GenSmoothNormals |
aiProcess_SplitLargeMeshes |
aiProcess_ConvertToLeftHanded |
aiProcess_SortByPType);
if(scene)
{
// Create the model that is getting filled out.
model = new SkinnedModel();
// Create the animator.
SceneAnimator* animator = new SceneAnimator();
animator->Init(scene);
model->SetAnimator(animator);
// Loop through all meshes.
for(int j = 0; j < scene->mNumMeshes; j++)
{
aiMesh* assimpMesh = scene->mMeshes[j];
// Calculate vertex weight and bone indices.
vector<Weights> weights = CalculateWeights(assimpMesh, animator);
vector<SkinnedVertex> vertices;
vector<UINT> indices;
// Add vertices to the vertex list.
for(int i = 0; i < assimpMesh->mNumVertices; i++)
{
aiVector3D v = assimpMesh->mVertices[i];
aiVector3D n = assimpMesh->mNormals[i];
aiVector3D t = aiVector3D(0, 0, 0);
if(assimpMesh->HasTextureCoords(0))
t = assimpMesh->mTextureCoords[0][i];
n = n.Normalize();
// Pos, normal and texture coordinates.
SkinnedVertex vertex(v.x, v.y, v.z, n.x, n.y, n.z, 0, 0, 1, t.x, t.y);
// Bone indices and weights.
for(int k = 0; k < weights[i].boneIndices.size(); k++)
vertex.BoneIndices[k] = weights[i].boneIndices[k];
vertex.Weights.x = weights[i].weights.size() >= 1 ? weights[i].weights[0] : 0;
vertex.Weights.y = weights[i].weights.size() >= 2 ? weights[i].weights[1] : 0;
vertex.Weights.z = weights[i].weights.size() >= 3 ? weights[i].weights[2] : 0;
vertices.push_back(vertex);
}
// Add indices to the index list.
for(int i = 0; i < assimpMesh->mNumFaces; i++)
for(int k = 0; k < assimpMesh->mFaces[i].mNumIndices; k++)
indices.push_back(assimpMesh->mFaces[i].mIndices[k]);
// Get the path to the texture in the directory.
aiString path;
aiMaterial* material = scene->mMaterials[assimpMesh->mMaterialIndex];
material->Get(AI_MATKEY_TEXTURE_DIFFUSE(0), path);
FindValidPath(&path);
// Extract all the ambient, diffuse and specular colors.
aiColor4D ambient, diffuse, specular;
material->Get(AI_MATKEY_COLOR_AMBIENT, ambient);
material->Get(AI_MATKEY_COLOR_DIFFUSE, diffuse);
material->Get(AI_MATKEY_COLOR_SPECULAR, specular);
// Create the mesh and its primitive.
SkinnedMesh* mesh = new SkinnedMesh();
Primitive* primitive = new Primitive(GlobalApp::GetD3DDevice(), vertices, indices);
mesh->SetPrimitive(primitive);
mesh->SetVertices(vertices);
mesh->SetIndices(indices);
mPrimtiveFactory->AddPrimitive(path.C_Str(), primitive);
// Replace .tga with .bmp [HACK].
string texturePath = path.C_Str();
int tgaPos = texturePath.find_first_of(".tga");
if(tgaPos != string::npos) {
texturePath.replace(texturePath.size()-4, 4, ".bmp");
path = texturePath;
}
// Any texture?
if(_stricmp(path.C_Str(), "") != 0)
mesh->LoadTexture(path.C_Str());
// Any normal map?
aiString nmap;
material->Get(AI_MATKEY_TEXTURE_HEIGHT(0), nmap);
FindValidPath(&nmap);
if(_stricmp(nmap.C_Str(), "") != 0)
mesh->SetNormalMap(GlobalApp::GetGraphics()->LoadTexture(nmap.C_Str()));
// [NOTE] The material is set to white.
mesh->SetMaterial(Material(Colors::White));
//mesh->SetMaterial(Material(diffuse, diffuse, diffuse));
model->SetFilename(filename);
// Add the mesh to the model.
model->AddMesh(mesh);
}
// Pre-calculate the bounding box.
model->CalculateAABB();
// Add the newly created mesh to the map and return it.
mSkinnedModelMap[filename] = model;
return mSkinnedModelMap[filename];
}
else {
char buffer[246];
sprintf(buffer, "Error loading model: %s", filename.c_str());
MessageBox(0, buffer, "Error!", 0);
mSkinnedModelMap[filename] = LoadSkinnedModel("models/box.obj");
return mSkinnedModelMap[filename];
}
}
