CC_FILE_ERROR ObjFilter::loadFile(QString filename, ccHObject& container, LoadParameters& parameters)
{
ccLog::Print(QString("[OBJ] ") + filename);
//open file
QFile file(filename);
if (!file.open(QFile::ReadOnly))
return CC_FERR_READING;
QTextStream stream(&file);
//current vertex shift
CCVector3d Pshift(0,0,0);
//vertices
ccPointCloud* vertices = new ccPointCloud("vertices");
int pointsRead = 0;
//facets
unsigned int facesRead = 0;
unsigned int totalFacesRead = 0;
int maxVertexIndex = -1;
//base mesh
ccMesh* baseMesh = new ccMesh(vertices);
baseMesh->setName(QFileInfo(filename).baseName());
//we need some space already reserved!
if (!baseMesh->reserve(128))
{
ccLog::Error("Not engouh memory!");
return CC_FERR_NOT_ENOUGH_MEMORY;
}
//groups (starting index + name)
std::vector<std::pair<unsigned,QString> > groups;
//materials
ccMaterialSet* materials = 0;
bool hasMaterial = false;
int currentMaterial = -1;
bool currentMaterialDefined = false;
bool materialsLoadFailed = true;
//texture coordinates
TextureCoordsContainer* texCoords = 0;
bool hasTexCoords = false;
int texCoordsRead = 0;
int maxTexCoordIndex = -1;
//normals
NormsIndexesTableType* normals = 0;
int normsRead = 0;
bool normalsPerFacet = false;
int maxTriNormIndex = -1;
//progress dialog
ccProgressDialog pDlg(true);
pDlg.setMethodTitle("OBJ file");
pDlg.setInfo("Loading in progress...");
pDlg.setRange(0,static_cast<int>(file.size()));
pDlg.show();
QApplication::processEvents();
//common warnings that can appear multiple time (we avoid to send too many messages to the console!)
enum OBJ_WARNINGS { INVALID_NORMALS = 0,
INVALID_INDEX = 1,
NOT_ENOUGH_MEMORY = 2,
INVALID_LINE = 3,
CANCELLED_BY_USER = 4,
};
bool objWarnings[5] = { false, false, false, false, false };
bool error = false;
try
{
unsigned lineCount = 0;
unsigned polyCount = 0;
QString currentLine = stream.readLine();
while (!currentLine.isNull())
{
if ((++lineCount % 2048) == 0)
{
if (pDlg.wasCanceled())
{
error = true;
objWarnings[CANCELLED_BY_USER] = true;
break;
}
pDlg.setValue(static_cast<int>(file.pos()));
QApplication::processEvents();
}
QStringList tokens = QString(currentLine).split(QRegExp("\\s+"),QString::SkipEmptyParts);
//skip comments & empty lines
if( tokens.empty() || tokens.front().startsWith('/',Qt::CaseInsensitive) || tokens.front().startsWith('#',Qt::CaseInsensitive) )
{
currentLine = stream.readLine();
continue;
}
/*** new vertex ***/
if (tokens.front() == "v")
{
//reserve more memory if necessary
if (vertices->size() == vertices->capacity())
{
if (!vertices->reserve(vertices->capacity()+MAX_NUMBER_OF_ELEMENTS_PER_CHUNK))
{
objWarnings[NOT_ENOUGH_MEMORY] = true;
error = true;
break;
}
}
//malformed line?
if (tokens.size() < 4)
{
objWarnings[INVALID_LINE] = true;
error = true;
break;
}
CCVector3d Pd( tokens[1].toDouble(), tokens[2].toDouble(), tokens[3].toDouble() );
//first point: check for 'big' coordinates
if (pointsRead == 0)
{
if (HandleGlobalShift(Pd,Pshift,parameters))
{
vertices->setGlobalShift(Pshift);
ccLog::Warning("[OBJ] Cloud has been recentered! Translation: (%.2f,%.2f,%.2f)",Pshift.x,Pshift.y,Pshift.z);
}
}
//shifted point
CCVector3 P = CCVector3::fromArray((Pd + Pshift).u);
vertices->addPoint(P);
++pointsRead;
}
/*** new vertex texture coordinates ***/
else if (tokens.front() == "vt")
{
//create and reserve memory for tex. coords container if necessary
if (!texCoords)
{
texCoords = new TextureCoordsContainer();
texCoords->link();
}
if (texCoords->currentSize() == texCoords->capacity())
{
if (!texCoords->reserve(texCoords->capacity() + MAX_NUMBER_OF_ELEMENTS_PER_CHUNK))
{
objWarnings[NOT_ENOUGH_MEMORY] = true;
error = true;
break;
}
}
//malformed line?
if (tokens.size() < 2)
{
objWarnings[INVALID_LINE] = true;
error = true;
break;
}
float T[2] = { T[0] = tokens[1].toFloat(), 0 };
if (tokens.size() > 2) //OBJ specification allows for only one value!!!
{
T[1] = tokens[2].toFloat();
}
texCoords->addElement(T);
++texCoordsRead;
}
/*** new vertex normal ***/
else if (tokens.front() == "vn") //--> in fact it can also be a facet normal!!!
{
//create and reserve memory for normals container if necessary
if (!normals)
{
normals = new NormsIndexesTableType;
normals->link();
}
if (normals->currentSize() == normals->capacity())
{
if (!normals->reserve(normals->capacity() + MAX_NUMBER_OF_ELEMENTS_PER_CHUNK))
{
objWarnings[NOT_ENOUGH_MEMORY] = true;
error = true;
break;
}
}
//malformed line?
if (tokens.size() < 4)
{
objWarnings[INVALID_LINE] = true;
error = true;
break;
}
CCVector3 N(static_cast<PointCoordinateType>(tokens[1].toDouble()),
static_cast<PointCoordinateType>(tokens[2].toDouble()),
static_cast<PointCoordinateType>(tokens[3].toDouble()));
if (fabs(N.norm2() - 1.0) > 0.005)
{
objWarnings[INVALID_NORMALS] = true;
N.normalize();
}
normsType nIndex = ccNormalVectors::GetNormIndex(N.u);
normals->addElement(nIndex); //we don't know yet if it's per-vertex or per-triangle normal...
++normsRead;
}
/*** new group ***/
else if (tokens.front() == "g" || tokens.front() == "o")
{
//update new group index
facesRead = 0;
//get the group name
QString groupName = (tokens.size() > 1 && !tokens[1].isEmpty() ? tokens[1] : "default");
for (int i=2; i<tokens.size(); ++i) //multiple parts?
groupName.append(QString(" ")+tokens[i]);
//push previous group descriptor (if none was pushed)
if (groups.empty() && totalFacesRead > 0)
groups.push_back(std::pair<unsigned,QString>(0,"default"));
//push new group descriptor
if (!groups.empty() && groups.back().first == totalFacesRead)
groups.back().second = groupName; //simply replace the group name if the previous group was empty!
else
groups.push_back(std::pair<unsigned,QString>(totalFacesRead,groupName));
polyCount = 0; //restart polyline count at 0!
}
/*** new face ***/
else if (tokens.front().startsWith('f'))
{
//malformed line?
if (tokens.size() < 4)
{
objWarnings[INVALID_LINE] = true;
currentLine = stream.readLine();
continue;
//error = true;
//break;
}
//read the face elements (singleton, pair or triplet)
std::vector<facetElement> currentFace;
{
for (int i=1; i<tokens.size(); ++i)
{
QStringList vertexTokens = tokens[i].split('/');
if (vertexTokens.size() == 0 || vertexTokens[0].isEmpty())
{
objWarnings[INVALID_LINE] = true;
error = true;
break;
}
else
{
//new vertex
facetElement fe; //(0,0,0) by default
fe.vIndex = vertexTokens[0].toInt();
if (vertexTokens.size() > 1 && !vertexTokens[1].isEmpty())
fe.tcIndex = vertexTokens[1].toInt();
if (vertexTokens.size() > 2 && !vertexTokens[2].isEmpty())
fe.nIndex = vertexTokens[2].toInt();
currentFace.push_back(fe);
}
}
}
if (error)
break;
if (currentFace.size() < 3)
{
ccLog::Warning("[OBJ] Malformed file: polygon on line %1 has less than 3 vertices!",lineCount);
error = true;
break;
}
//first vertex
std::vector<facetElement>::iterator A = currentFace.begin();
//the very first vertex of the group tells us about the whole sequence
if (facesRead == 0)
{
//we have a tex. coord index as second vertex element!
if (!hasTexCoords && A->tcIndex != 0 && !materialsLoadFailed)
{
if (!baseMesh->reservePerTriangleTexCoordIndexes())
{
objWarnings[NOT_ENOUGH_MEMORY] = true;
error = true;
break;
}
for (unsigned int i=0; i<totalFacesRead; ++i)
baseMesh->addTriangleTexCoordIndexes(-1, -1, -1);
hasTexCoords = true;
}
//we have a normal index as third vertex element!
if (!normalsPerFacet && A->nIndex != 0)
{
//so the normals are 'per-facet'
if (!baseMesh->reservePerTriangleNormalIndexes())
{
objWarnings[NOT_ENOUGH_MEMORY] = true;
error = true;
break;
}
for (unsigned int i=0; i<totalFacesRead; ++i)
baseMesh->addTriangleNormalIndexes(-1, -1, -1);
normalsPerFacet = true;
}
}
//we process all vertices accordingly
for (std::vector<facetElement>::iterator it = currentFace.begin() ; it!=currentFace.end(); ++it)
{
facetElement& vertex = *it;
//vertex index
{
if (!vertex.updatePointIndex(pointsRead))
{
objWarnings[INVALID_INDEX] = true;
error = true;
break;
}
if (vertex.vIndex > maxVertexIndex)
maxVertexIndex = vertex.vIndex;
}
//should we have a tex. coord index as second vertex element?
if (hasTexCoords && currentMaterialDefined)
{
if (!vertex.updateTexCoordIndex(texCoordsRead))
{
objWarnings[INVALID_INDEX] = true;
error = true;
break;
}
if (vertex.tcIndex > maxTexCoordIndex)
maxTexCoordIndex = vertex.tcIndex;
}
//should we have a normal index as third vertex element?
if (normalsPerFacet)
{
if (!vertex.updateNormalIndex(normsRead))
{
objWarnings[INVALID_INDEX] = true;
error = true;
break;
}
if (vertex.nIndex > maxTriNormIndex)
maxTriNormIndex = vertex.nIndex;
}
}
//don't forget material (common for all vertices)
if (currentMaterialDefined && !materialsLoadFailed)
{
if (!hasMaterial)
{
if (!baseMesh->reservePerTriangleMtlIndexes())
{
objWarnings[NOT_ENOUGH_MEMORY] = true;
error = true;
break;
}
for (unsigned int i=0; i<totalFacesRead; ++i)
baseMesh->addTriangleMtlIndex(-1);
hasMaterial = true;
}
}
if (error)
break;
//Now, let's tesselate the whole polygon
//FIXME: yeah, we do very ulgy tesselation here!
std::vector<facetElement>::const_iterator B = A+1;
std::vector<facetElement>::const_iterator C = B+1;
for ( ; C != currentFace.end(); ++B,++C)
{
//need more space?
if (baseMesh->size() == baseMesh->maxSize())
{
if (!baseMesh->reserve(baseMesh->size()+128))
{
objWarnings[NOT_ENOUGH_MEMORY] = true;
error = true;
break;
}
}
//push new triangle
baseMesh->addTriangle(A->vIndex, B->vIndex, C->vIndex);
++facesRead;
++totalFacesRead;
if (hasMaterial)
baseMesh->addTriangleMtlIndex(currentMaterial);
if (hasTexCoords)
baseMesh->addTriangleTexCoordIndexes(A->tcIndex, B->tcIndex, C->tcIndex);
if (normalsPerFacet)
baseMesh->addTriangleNormalIndexes(A->nIndex, B->nIndex, C->nIndex);
}
}
/*** polyline ***/
else if (tokens.front().startsWith('l'))
{
//malformed line?
if (tokens.size() < 3)
{
objWarnings[INVALID_LINE] = true;
currentLine = stream.readLine();
continue;
}
//read the face elements (singleton, pair or triplet)
ccPolyline* polyline = new ccPolyline(vertices);
if (!polyline->reserve(static_cast<unsigned>(tokens.size()-1)))
{
//not enough memory
objWarnings[NOT_ENOUGH_MEMORY] = true;
delete polyline;
polyline = 0;
currentLine = stream.readLine();
continue;
}
for (int i=1; i<tokens.size(); ++i)
{
//get next polyline's vertex index
QStringList vertexTokens = tokens[i].split('/');
if (vertexTokens.size() == 0 || vertexTokens[0].isEmpty())
{
objWarnings[INVALID_LINE] = true;
error = true;
break;
}
else
{
int index = vertexTokens[0].toInt(); //we ignore normal index (if any!)
if (!UpdatePointIndex(index,pointsRead))
{
objWarnings[INVALID_INDEX] = true;
error = true;
break;
}
polyline->addPointIndex(index);
}
}
if (error)
{
delete polyline;
polyline = 0;
break;
}
polyline->setVisible(true);
QString name = groups.empty() ? QString("Line") : groups.back().second+QString(".line");
polyline->setName(QString("%1 %2").arg(name).arg(++polyCount));
vertices->addChild(polyline);
}
/*** material ***/
else if (tokens.front() == "usemtl") //see 'MTL file' below
{
if (materials) //otherwise we have failed to load MTL file!!!
{
QString mtlName = currentLine.mid(7).trimmed();
//DGM: in case there's space characters in the material name, we must read it again from the original line buffer
//QString mtlName = (tokens.size() > 1 && !tokens[1].isEmpty() ? tokens[1] : "");
currentMaterial = (!mtlName.isEmpty() ? materials->findMaterialByName(mtlName) : -1);
currentMaterialDefined = true;
}
}
/*** material file (MTL) ***/
else if (tokens.front() == "mtllib")
{
//malformed line?
if (tokens.size() < 2 || tokens[1].isEmpty())
{
objWarnings[INVALID_LINE] = true;
}
else
{
//we build the whole MTL filename + path
//DGM: in case there's space characters in the filename, we must read it again from the original line buffer
//QString mtlFilename = tokens[1];
QString mtlFilename = currentLine.mid(7).trimmed();
ccLog::Print(QString("[OBJ] Material file: ")+mtlFilename);
QString mtlPath = QFileInfo(filename).canonicalPath();
//we try to load it
if (!materials)
{
materials = new ccMaterialSet("materials");
materials->link();
}
size_t oldSize = materials->size();
QStringList errors;
if (ccMaterialSet::ParseMTL(mtlPath,mtlFilename,*materials,errors))
{
ccLog::Print("[OBJ] %i materials loaded",materials->size()-oldSize);
materialsLoadFailed = false;
}
else
{
ccLog::Error(QString("[OBJ] Failed to load material file! (should be in '%1')").arg(mtlPath+'/'+QString(mtlFilename)));
materialsLoadFailed = true;
}
if (!errors.empty())
{
for (int i=0; i<errors.size(); ++i)
ccLog::Warning(QString("[OBJ::Load::MTL parser] ")+errors[i]);
}
if (materials->empty())
{
materials->release();
materials=0;
materialsLoadFailed = true;
}
}
}
///*** shading group ***/
//else if (tokens.front() == "s")
//{
// //ignored!
//}
if (error)
break;
currentLine = stream.readLine();
}
}
catch (const std::bad_alloc&)
{
//not enough memory
objWarnings[NOT_ENOUGH_MEMORY] = true;
error = true;
}
file.close();
//1st check
if (!error && pointsRead == 0)
{
//of course if there's no vertex, that's the end of the story ...
ccLog::Warning("[OBJ] Malformed file: no vertex in file!");
error = true;
}
if (!error)
{
ccLog::Print("[OBJ] %i points, %u faces",pointsRead,totalFacesRead);
if (texCoordsRead > 0 || normsRead > 0)
ccLog::Print("[OBJ] %i tex. coords, %i normals",texCoordsRead,normsRead);
//do some cleaning
if (vertices->size() < vertices->capacity())
vertices->resize(vertices->size());
if (normals && normals->currentSize() < normals->capacity())
normals->resize(normals->currentSize());
if (texCoords && texCoords->currentSize() < texCoords->capacity())
texCoords->resize(texCoords->currentSize());
if (baseMesh->size() == 0)
{
delete baseMesh;
baseMesh = 0;
}
else if (baseMesh->maxSize() > baseMesh->size())
{
baseMesh->resize(baseMesh->size());
}
if ( maxVertexIndex >= pointsRead
|| maxTexCoordIndex >= texCoordsRead
|| maxTriNormIndex >= normsRead)
{
//hum, we've got a problem here
ccLog::Warning("[OBJ] Malformed file: indexes go higher than the number of elements! (v=%i/tc=%i/n=%i)",maxVertexIndex,maxTexCoordIndex,maxTriNormIndex);
if (maxVertexIndex >= pointsRead)
{
error = true;
}
else
{
objWarnings[INVALID_INDEX] = true;
if (maxTexCoordIndex >= texCoordsRead)
{
texCoords->release();
texCoords = 0;
materials->release();
materials = 0;
}
if (maxTriNormIndex >= normsRead)
{
normals->release();
normals = 0;
}
}
}
if (!error && baseMesh)
{
if (normals && normalsPerFacet)
{
baseMesh->setTriNormsTable(normals);
baseMesh->showTriNorms(true);
}
if (materials)
{
baseMesh->setMaterialSet(materials);
baseMesh->showMaterials(true);
}
if (texCoords)
{
if (materials)
{
baseMesh->setTexCoordinatesTable(texCoords);
}
else
{
ccLog::Warning("[OBJ] Texture coordinates were defined but no material could be loaded!");
}
}
//normals: if the obj file doesn't provide any, should we compute them?
if (!normals)
{
//DGM: normals can be per-vertex or per-triangle so it's better to let the user do it himself later
//Moreover it's not always good idea if the user doesn't want normals (especially in ccViewer!)
//if (!materials && !baseMesh->hasColors()) //yes if no material is available!
//{
// ccLog::Print("[OBJ] Mesh has no normal! We will compute them automatically");
// baseMesh->computeNormals();
// baseMesh->showNormals(true);
//}
//else
{
ccLog::Warning("[OBJ] Mesh has no normal! You can manually compute them (select it then call \"Edit > Normals > Compute\")");
}
}
//create sub-meshes if necessary
ccLog::Print("[OBJ] 1 mesh loaded - %i group(s)", groups.size());
if (groups.size() > 1)
{
for (size_t i=0; i<groups.size(); ++i)
{
const QString& groupName = groups[i].second;
unsigned startIndex = groups[i].first;
unsigned endIndex = (i+1 == groups.size() ? baseMesh->size() : groups[i+1].first);
if (startIndex == endIndex)
{
continue;
}
ccSubMesh* subTri = new ccSubMesh(baseMesh);
if (subTri->reserve(endIndex-startIndex))
{
subTri->addTriangleIndex(startIndex,endIndex);
subTri->setName(groupName);
subTri->showMaterials(baseMesh->materialsShown());
subTri->showNormals(baseMesh->normalsShown());
subTri->showTriNorms(baseMesh->triNormsShown());
//subTri->showColors(baseMesh->colorsShown());
//subTri->showWired(baseMesh->isShownAsWire());
baseMesh->addChild(subTri);
}
else
{
delete subTri;
subTri = 0;
objWarnings[NOT_ENOUGH_MEMORY] = true;
}
}
baseMesh->setVisible(false);
vertices->setLocked(true);
}
baseMesh->addChild(vertices);
//DGM: we can't deactive the vertices if it has children! (such as polyline)
if (vertices->getChildrenNumber() != 0)
vertices->setVisible(false);
else
vertices->setEnabled(false);
container.addChild(baseMesh);
}
if (!baseMesh && vertices->size() != 0)
{
//no (valid) mesh!
container.addChild(vertices);
//we hide the vertices if the entity has children (probably polylines!)
if (vertices->getChildrenNumber() != 0)
{
vertices->setVisible(false);
}
}
//special case: normals held by cloud!
if (normals && !normalsPerFacet)
{
if (normsRead == pointsRead) //must be 'per-vertex' normals
{
vertices->setNormsTable(normals);
if (baseMesh)
baseMesh->showNormals(true);
}
else
{
ccLog::Warning("File contains normals which seem to be neither per-vertex nor per-face!!! We had to ignore them...");
}
}
}
if (error)
{
if (baseMesh)
delete baseMesh;
if (vertices)
delete vertices;
}
//release shared structures
if (normals)
{
normals->release();
normals = 0;
}
if (texCoords)
{
texCoords->release();
texCoords = 0;
}
if (materials)
{
materials->release();
materials = 0;
}
pDlg.close();
//potential warnings
if (objWarnings[INVALID_NORMALS])
ccLog::Warning("[OBJ] Some normals in file were invalid. You should re-compute them (select entity, then \"Edit > Normals > Compute\")");
if (objWarnings[INVALID_INDEX])
ccLog::Warning("[OBJ] File is malformed! Check indexes...");
if (objWarnings[NOT_ENOUGH_MEMORY])
ccLog::Warning("[OBJ] Not enough memory!");
if (objWarnings[INVALID_LINE])
ccLog::Warning("[OBJ] File is malformed! Missing data.");
if (error)
{
if (objWarnings[NOT_ENOUGH_MEMORY])
return CC_FERR_NOT_ENOUGH_MEMORY;
else if (objWarnings[CANCELLED_BY_USER])
return CC_FERR_CANCELED_BY_USER;
else
return CC_FERR_MALFORMED_FILE;
}
else
{
return CC_FERR_NO_ERROR;
}
}
