920 lines
30 KiB
C++
920 lines
30 KiB
C++
/*
|
|
---------------------------------------------------------------------------
|
|
Open Asset Import Library (assimp)
|
|
---------------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2017, assimp team
|
|
|
|
|
|
All rights reserved.
|
|
|
|
Redistribution and use of this software in source and binary forms,
|
|
with or without modification, are permitted provided that the following
|
|
conditions are met:
|
|
|
|
* Redistributions of source code must retain the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer in the documentation and/or other
|
|
materials provided with the distribution.
|
|
|
|
* Neither the name of the assimp team, nor the names of its
|
|
contributors may be used to endorse or promote products
|
|
derived from this software without specific prior
|
|
written permission of the assimp team.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
---------------------------------------------------------------------------
|
|
*/
|
|
|
|
/** @file DXFLoader.cpp
|
|
* @brief Implementation of the DXF importer class
|
|
*/
|
|
|
|
|
|
#ifndef ASSIMP_BUILD_NO_DXF_IMPORTER
|
|
|
|
#include "DXFLoader.h"
|
|
#include "ParsingUtils.h"
|
|
#include "ConvertToLHProcess.h"
|
|
#include "fast_atof.h"
|
|
|
|
#include "DXFHelper.h"
|
|
#include <assimp/IOSystem.hpp>
|
|
#include <assimp/scene.h>
|
|
#include <assimp/importerdesc.h>
|
|
|
|
#include <numeric>
|
|
|
|
using namespace Assimp;
|
|
|
|
// AutoCAD Binary DXF<CR><LF><SUB><NULL>
|
|
#define AI_DXF_BINARY_IDENT ("AutoCAD Binary DXF\r\n\x1a\0")
|
|
#define AI_DXF_BINARY_IDENT_LEN (24)
|
|
|
|
// default vertex color that all uncolored vertices will receive
|
|
#define AI_DXF_DEFAULT_COLOR aiColor4D(0.6f,0.6f,0.6f,0.6f)
|
|
|
|
// color indices for DXF - 16 are supported, the table is
|
|
// taken directly from the DXF spec.
|
|
static aiColor4D g_aclrDxfIndexColors[] =
|
|
{
|
|
aiColor4D (0.6f, 0.6f, 0.6f, 1.0f),
|
|
aiColor4D (1.0f, 0.0f, 0.0f, 1.0f), // red
|
|
aiColor4D (0.0f, 1.0f, 0.0f, 1.0f), // green
|
|
aiColor4D (0.0f, 0.0f, 1.0f, 1.0f), // blue
|
|
aiColor4D (0.3f, 1.0f, 0.3f, 1.0f), // light green
|
|
aiColor4D (0.3f, 0.3f, 1.0f, 1.0f), // light blue
|
|
aiColor4D (1.0f, 0.3f, 0.3f, 1.0f), // light red
|
|
aiColor4D (1.0f, 0.0f, 1.0f, 1.0f), // pink
|
|
aiColor4D (1.0f, 0.6f, 0.0f, 1.0f), // orange
|
|
aiColor4D (0.6f, 0.3f, 0.0f, 1.0f), // dark orange
|
|
aiColor4D (1.0f, 1.0f, 0.0f, 1.0f), // yellow
|
|
aiColor4D (0.3f, 0.3f, 0.3f, 1.0f), // dark gray
|
|
aiColor4D (0.8f, 0.8f, 0.8f, 1.0f), // light gray
|
|
aiColor4D (0.0f, 00.f, 0.0f, 1.0f), // black
|
|
aiColor4D (1.0f, 1.0f, 1.0f, 1.0f), // white
|
|
aiColor4D (0.6f, 0.0f, 1.0f, 1.0f) // violet
|
|
};
|
|
#define AI_DXF_NUM_INDEX_COLORS (sizeof(g_aclrDxfIndexColors)/sizeof(g_aclrDxfIndexColors[0]))
|
|
#define AI_DXF_ENTITIES_MAGIC_BLOCK "$ASSIMP_ENTITIES_MAGIC"
|
|
|
|
|
|
static const aiImporterDesc desc = {
|
|
"Drawing Interchange Format (DXF) Importer",
|
|
"",
|
|
"",
|
|
"",
|
|
aiImporterFlags_SupportTextFlavour | aiImporterFlags_LimitedSupport,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
"dxf"
|
|
};
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Constructor to be privately used by Importer
|
|
DXFImporter::DXFImporter()
|
|
{}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Destructor, private as well
|
|
DXFImporter::~DXFImporter()
|
|
{}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Returns whether the class can handle the format of the given file.
|
|
bool DXFImporter::CanRead( const std::string& pFile, IOSystem* /*pIOHandler*/, bool /*checkSig*/) const
|
|
{
|
|
return SimpleExtensionCheck(pFile,"dxf");
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Get a list of all supported file extensions
|
|
const aiImporterDesc* DXFImporter::GetInfo () const
|
|
{
|
|
return &desc;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Imports the given file into the given scene structure.
|
|
void DXFImporter::InternReadFile( const std::string& pFile,
|
|
aiScene* pScene,
|
|
IOSystem* pIOHandler)
|
|
{
|
|
std::shared_ptr<IOStream> file = std::shared_ptr<IOStream>( pIOHandler->Open( pFile) );
|
|
|
|
// Check whether we can read the file
|
|
if( file.get() == NULL) {
|
|
throw DeadlyImportError( "Failed to open DXF file " + pFile + "");
|
|
}
|
|
|
|
// check whether this is a binaray DXF file - we can't read binary DXF files :-(
|
|
char buff[AI_DXF_BINARY_IDENT_LEN+1] = {0};
|
|
file->Read(buff,AI_DXF_BINARY_IDENT_LEN,1);
|
|
|
|
if (!strncmp(AI_DXF_BINARY_IDENT,buff,AI_DXF_BINARY_IDENT_LEN)) {
|
|
throw DeadlyImportError("DXF: Binary files are not supported at the moment");
|
|
}
|
|
|
|
// DXF files can grow very large, so read them via the StreamReader,
|
|
// which will choose a suitable strategy.
|
|
file->Seek(0,aiOrigin_SET);
|
|
StreamReaderLE stream( file );
|
|
|
|
DXF::LineReader reader (stream);
|
|
DXF::FileData output;
|
|
|
|
// now get all lines of the file and process top-level sections
|
|
bool eof = false;
|
|
while(!reader.End()) {
|
|
|
|
// blocks table - these 'build blocks' are later (in ENTITIES)
|
|
// referenced an included via INSERT statements.
|
|
if (reader.Is(2,"BLOCKS")) {
|
|
ParseBlocks(reader,output);
|
|
continue;
|
|
}
|
|
|
|
// primary entity table
|
|
if (reader.Is(2,"ENTITIES")) {
|
|
ParseEntities(reader,output);
|
|
continue;
|
|
}
|
|
|
|
// skip unneeded sections entirely to avoid any problems with them
|
|
// altogether.
|
|
else if (reader.Is(2,"CLASSES") || reader.Is(2,"TABLES")) {
|
|
SkipSection(reader);
|
|
continue;
|
|
}
|
|
|
|
else if (reader.Is(2,"HEADER")) {
|
|
ParseHeader(reader,output);
|
|
continue;
|
|
}
|
|
|
|
// comments
|
|
else if (reader.Is(999)) {
|
|
DefaultLogger::get()->info("DXF Comment: " + reader.Value());
|
|
}
|
|
|
|
// don't read past the official EOF sign
|
|
else if (reader.Is(0,"EOF")) {
|
|
eof = true;
|
|
break;
|
|
}
|
|
|
|
++reader;
|
|
}
|
|
if (!eof) {
|
|
DefaultLogger::get()->warn("DXF: EOF reached, but did not encounter DXF EOF marker");
|
|
}
|
|
|
|
ConvertMeshes(pScene,output);
|
|
|
|
// Now rotate the whole scene by 90 degrees around the x axis to convert from AutoCAD's to Assimp's coordinate system
|
|
pScene->mRootNode->mTransformation = aiMatrix4x4(
|
|
1.f,0.f,0.f,0.f,
|
|
0.f,0.f,1.f,0.f,
|
|
0.f,-1.f,0.f,0.f,
|
|
0.f,0.f,0.f,1.f) * pScene->mRootNode->mTransformation;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output)
|
|
{
|
|
// the process of resolving all the INSERT statements can grow the
|
|
// polycount excessively, so log the original number.
|
|
// XXX Option to import blocks as separate nodes?
|
|
if (!DefaultLogger::isNullLogger()) {
|
|
|
|
unsigned int vcount = 0, icount = 0;
|
|
for (const DXF::Block& bl : output.blocks) {
|
|
for (std::shared_ptr<const DXF::PolyLine> pl : bl.lines) {
|
|
vcount += static_cast<unsigned int>(pl->positions.size());
|
|
icount += static_cast<unsigned int>(pl->counts.size());
|
|
}
|
|
}
|
|
|
|
DefaultLogger::get()->debug((Formatter::format("DXF: Unexpanded polycount is "),
|
|
icount,", vertex count is ",vcount
|
|
));
|
|
}
|
|
|
|
if (! output.blocks.size() ) {
|
|
throw DeadlyImportError("DXF: no data blocks loaded");
|
|
}
|
|
|
|
DXF::Block* entities = 0;
|
|
|
|
// index blocks by name
|
|
DXF::BlockMap blocks_by_name;
|
|
for (DXF::Block& bl : output.blocks) {
|
|
blocks_by_name[bl.name] = &bl;
|
|
if ( !entities && bl.name == AI_DXF_ENTITIES_MAGIC_BLOCK ) {
|
|
entities = &bl;
|
|
}
|
|
}
|
|
|
|
if (!entities) {
|
|
throw DeadlyImportError("DXF: no ENTITIES data block loaded");
|
|
}
|
|
|
|
typedef std::map<std::string, unsigned int> LayerMap;
|
|
|
|
LayerMap layers;
|
|
std::vector< std::vector< const DXF::PolyLine*> > corr;
|
|
|
|
// now expand all block references in the primary ENTITIES block
|
|
// XXX this involves heavy memory copying, consider a faster solution for future versions.
|
|
ExpandBlockReferences(*entities,blocks_by_name);
|
|
|
|
unsigned int cur = 0;
|
|
for (std::shared_ptr<const DXF::PolyLine> pl : entities->lines) {
|
|
if (pl->positions.size()) {
|
|
|
|
std::map<std::string, unsigned int>::iterator it = layers.find(pl->layer);
|
|
if (it == layers.end()) {
|
|
++pScene->mNumMeshes;
|
|
|
|
layers[pl->layer] = cur++;
|
|
|
|
std::vector< const DXF::PolyLine* > pv;
|
|
pv.push_back(&*pl);
|
|
|
|
corr.push_back(pv);
|
|
}
|
|
else {
|
|
corr[(*it).second].push_back(&*pl);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!pScene->mNumMeshes) {
|
|
throw DeadlyImportError("DXF: this file contains no 3d data");
|
|
}
|
|
|
|
pScene->mMeshes = new aiMesh*[ pScene->mNumMeshes ] ();
|
|
|
|
for(const LayerMap::value_type& elem : layers){
|
|
aiMesh* const mesh = pScene->mMeshes[elem.second] = new aiMesh();
|
|
mesh->mName.Set(elem.first);
|
|
|
|
unsigned int cvert = 0,cface = 0;
|
|
for(const DXF::PolyLine* pl : corr[elem.second]){
|
|
// sum over all faces since we need to 'verbosify' them.
|
|
cvert += std::accumulate(pl->counts.begin(),pl->counts.end(),0);
|
|
cface += static_cast<unsigned int>(pl->counts.size());
|
|
}
|
|
|
|
aiVector3D* verts = mesh->mVertices = new aiVector3D[cvert];
|
|
aiColor4D* colors = mesh->mColors[0] = new aiColor4D[cvert];
|
|
aiFace* faces = mesh->mFaces = new aiFace[cface];
|
|
|
|
mesh->mNumVertices = cvert;
|
|
mesh->mNumFaces = cface;
|
|
|
|
unsigned int prims = 0;
|
|
unsigned int overall_indices = 0;
|
|
for(const DXF::PolyLine* pl : corr[elem.second]){
|
|
|
|
std::vector<unsigned int>::const_iterator it = pl->indices.begin();
|
|
for(unsigned int facenumv : pl->counts) {
|
|
aiFace& face = *faces++;
|
|
face.mIndices = new unsigned int[face.mNumIndices = facenumv];
|
|
|
|
for (unsigned int i = 0; i < facenumv; ++i) {
|
|
face.mIndices[i] = overall_indices++;
|
|
|
|
ai_assert(pl->positions.size() == pl->colors.size());
|
|
if (*it >= pl->positions.size()) {
|
|
throw DeadlyImportError("DXF: vertex index out of bounds");
|
|
}
|
|
|
|
*verts++ = pl->positions[*it];
|
|
*colors++ = pl->colors[*it++];
|
|
}
|
|
|
|
// set primitive flags now, this saves the extra pass in ScenePreprocessor.
|
|
switch(face.mNumIndices) {
|
|
case 1:
|
|
prims |= aiPrimitiveType_POINT;
|
|
break;
|
|
case 2:
|
|
prims |= aiPrimitiveType_LINE;
|
|
break;
|
|
case 3:
|
|
prims |= aiPrimitiveType_TRIANGLE;
|
|
break;
|
|
default:
|
|
prims |= aiPrimitiveType_POLYGON;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
mesh->mPrimitiveTypes = prims;
|
|
mesh->mMaterialIndex = 0;
|
|
}
|
|
|
|
GenerateHierarchy(pScene,output);
|
|
GenerateMaterials(pScene,output);
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void DXFImporter::ExpandBlockReferences(DXF::Block& bl,const DXF::BlockMap& blocks_by_name)
|
|
{
|
|
for (const DXF::InsertBlock& insert : bl.insertions) {
|
|
|
|
// first check if the referenced blocks exists ...
|
|
const DXF::BlockMap::const_iterator it = blocks_by_name.find(insert.name);
|
|
if (it == blocks_by_name.end()) {
|
|
DefaultLogger::get()->error((Formatter::format("DXF: Failed to resolve block reference: "),
|
|
insert.name,"; skipping"
|
|
));
|
|
continue;
|
|
}
|
|
|
|
// XXX this would be the place to implement recursive expansion if needed.
|
|
const DXF::Block& bl_src = *(*it).second;
|
|
|
|
for (std::shared_ptr<const DXF::PolyLine> pl_in : bl_src.lines) {
|
|
std::shared_ptr<DXF::PolyLine> pl_out = std::shared_ptr<DXF::PolyLine>(new DXF::PolyLine(*pl_in));
|
|
|
|
if (bl_src.base.Length() || insert.scale.x!=1.f || insert.scale.y!=1.f || insert.scale.z!=1.f || insert.angle || insert.pos.Length()) {
|
|
// manual coordinate system transformation
|
|
// XXX order
|
|
aiMatrix4x4 trafo, tmp;
|
|
aiMatrix4x4::Translation(-bl_src.base,trafo);
|
|
trafo *= aiMatrix4x4::Scaling(insert.scale,tmp);
|
|
trafo *= aiMatrix4x4::Translation(insert.pos,tmp);
|
|
|
|
// XXX rotation currently ignored - I didn't find an appropriate sample model.
|
|
if (insert.angle != 0.f) {
|
|
DefaultLogger::get()->warn("DXF: BLOCK rotation not currently implemented");
|
|
}
|
|
|
|
for (aiVector3D& v : pl_out->positions) {
|
|
v *= trafo;
|
|
}
|
|
}
|
|
|
|
bl.lines.push_back(pl_out);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void DXFImporter::GenerateMaterials(aiScene* pScene, DXF::FileData& /*output*/)
|
|
{
|
|
// generate an almost-white default material. Reason:
|
|
// the default vertex color is GREY, so we are
|
|
// already at Assimp's usual default color.
|
|
// generate a default material
|
|
aiMaterial* pcMat = new aiMaterial();
|
|
aiString s;
|
|
s.Set(AI_DEFAULT_MATERIAL_NAME);
|
|
pcMat->AddProperty(&s, AI_MATKEY_NAME);
|
|
|
|
aiColor4D clrDiffuse(0.9f,0.9f,0.9f,1.0f);
|
|
pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_DIFFUSE);
|
|
|
|
clrDiffuse = aiColor4D(1.0f,1.0f,1.0f,1.0f);
|
|
pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_SPECULAR);
|
|
|
|
clrDiffuse = aiColor4D(0.05f,0.05f,0.05f,1.0f);
|
|
pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_AMBIENT);
|
|
|
|
pScene->mNumMaterials = 1;
|
|
pScene->mMaterials = new aiMaterial*[1];
|
|
pScene->mMaterials[0] = pcMat;
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void DXFImporter::GenerateHierarchy(aiScene* pScene, DXF::FileData& /*output*/)
|
|
{
|
|
// generate the output scene graph, which is just the root node with a single child for each layer.
|
|
pScene->mRootNode = new aiNode();
|
|
pScene->mRootNode->mName.Set("<DXF_ROOT>");
|
|
|
|
if (1 == pScene->mNumMeshes) {
|
|
pScene->mRootNode->mMeshes = new unsigned int[ pScene->mRootNode->mNumMeshes = 1 ];
|
|
pScene->mRootNode->mMeshes[0] = 0;
|
|
}
|
|
else
|
|
{
|
|
pScene->mRootNode->mChildren = new aiNode*[ pScene->mRootNode->mNumChildren = pScene->mNumMeshes ];
|
|
for (unsigned int m = 0; m < pScene->mRootNode->mNumChildren;++m) {
|
|
aiNode* p = pScene->mRootNode->mChildren[m] = new aiNode();
|
|
p->mName = pScene->mMeshes[m]->mName;
|
|
|
|
p->mMeshes = new unsigned int[p->mNumMeshes = 1];
|
|
p->mMeshes[0] = m;
|
|
p->mParent = pScene->mRootNode;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void DXFImporter::SkipSection(DXF::LineReader& reader)
|
|
{
|
|
for( ;!reader.End() && !reader.Is(0,"ENDSEC"); reader++);
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void DXFImporter::ParseHeader(DXF::LineReader& reader, DXF::FileData& /*output*/)
|
|
{
|
|
for( ;!reader.End() && !reader.Is(0,"ENDSEC"); reader++);
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void DXFImporter::ParseBlocks(DXF::LineReader& reader, DXF::FileData& output)
|
|
{
|
|
while( !reader.End() && !reader.Is(0,"ENDSEC")) {
|
|
if (reader.Is(0,"BLOCK")) {
|
|
ParseBlock(++reader,output);
|
|
continue;
|
|
}
|
|
++reader;
|
|
}
|
|
|
|
DefaultLogger::get()->debug((Formatter::format("DXF: got "),
|
|
output.blocks.size()," entries in BLOCKS"
|
|
));
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void DXFImporter::ParseBlock(DXF::LineReader& reader, DXF::FileData& output)
|
|
{
|
|
// push a new block onto the stack.
|
|
output.blocks.push_back( DXF::Block() );
|
|
DXF::Block& block = output.blocks.back();
|
|
|
|
while( !reader.End() && !reader.Is(0,"ENDBLK")) {
|
|
|
|
switch(reader.GroupCode()) {
|
|
case 2:
|
|
block.name = reader.Value();
|
|
break;
|
|
|
|
case 10:
|
|
block.base.x = reader.ValueAsFloat();
|
|
break;
|
|
case 20:
|
|
block.base.y = reader.ValueAsFloat();
|
|
break;
|
|
case 30:
|
|
block.base.z = reader.ValueAsFloat();
|
|
break;
|
|
}
|
|
|
|
if (reader.Is(0,"POLYLINE")) {
|
|
ParsePolyLine(++reader,output);
|
|
continue;
|
|
}
|
|
|
|
// XXX is this a valid case?
|
|
if (reader.Is(0,"INSERT")) {
|
|
DefaultLogger::get()->warn("DXF: INSERT within a BLOCK not currently supported; skipping");
|
|
for( ;!reader.End() && !reader.Is(0,"ENDBLK"); ++reader);
|
|
break;
|
|
}
|
|
|
|
else if (reader.Is(0,"3DFACE") || reader.Is(0,"LINE") || reader.Is(0,"3DLINE")) {
|
|
//http://sourceforge.net/tracker/index.php?func=detail&aid=2970566&group_id=226462&atid=1067632
|
|
Parse3DFace(++reader, output);
|
|
continue;
|
|
}
|
|
++reader;
|
|
}
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void DXFImporter::ParseEntities(DXF::LineReader& reader, DXF::FileData& output)
|
|
{
|
|
// push a new block onto the stack.
|
|
output.blocks.push_back( DXF::Block() );
|
|
DXF::Block& block = output.blocks.back();
|
|
|
|
block.name = AI_DXF_ENTITIES_MAGIC_BLOCK;
|
|
|
|
while( !reader.End() && !reader.Is(0,"ENDSEC")) {
|
|
if (reader.Is(0,"POLYLINE")) {
|
|
ParsePolyLine(++reader,output);
|
|
continue;
|
|
}
|
|
|
|
else if (reader.Is(0,"INSERT")) {
|
|
ParseInsertion(++reader,output);
|
|
continue;
|
|
}
|
|
|
|
else if (reader.Is(0,"3DFACE") || reader.Is(0,"LINE") || reader.Is(0,"3DLINE")) {
|
|
//http://sourceforge.net/tracker/index.php?func=detail&aid=2970566&group_id=226462&atid=1067632
|
|
Parse3DFace(++reader, output);
|
|
continue;
|
|
}
|
|
|
|
++reader;
|
|
}
|
|
|
|
DefaultLogger::get()->debug((Formatter::format("DXF: got "),
|
|
block.lines.size()," polylines and ", block.insertions.size() ," inserted blocks in ENTITIES"
|
|
));
|
|
}
|
|
|
|
|
|
void DXFImporter::ParseInsertion(DXF::LineReader& reader, DXF::FileData& output)
|
|
{
|
|
output.blocks.back().insertions.push_back( DXF::InsertBlock() );
|
|
DXF::InsertBlock& bl = output.blocks.back().insertions.back();
|
|
|
|
while( !reader.End() && !reader.Is(0)) {
|
|
|
|
switch(reader.GroupCode())
|
|
{
|
|
// name of referenced block
|
|
case 2:
|
|
bl.name = reader.Value();
|
|
break;
|
|
|
|
// translation
|
|
case 10:
|
|
bl.pos.x = reader.ValueAsFloat();
|
|
break;
|
|
case 20:
|
|
bl.pos.y = reader.ValueAsFloat();
|
|
break;
|
|
case 30:
|
|
bl.pos.z = reader.ValueAsFloat();
|
|
break;
|
|
|
|
// scaling
|
|
case 41:
|
|
bl.scale.x = reader.ValueAsFloat();
|
|
break;
|
|
case 42:
|
|
bl.scale.y = reader.ValueAsFloat();
|
|
break;
|
|
case 43:
|
|
bl.scale.z = reader.ValueAsFloat();
|
|
break;
|
|
|
|
// rotation angle
|
|
case 50:
|
|
bl.angle = reader.ValueAsFloat();
|
|
break;
|
|
}
|
|
reader++;
|
|
}
|
|
}
|
|
|
|
#define DXF_POLYLINE_FLAG_CLOSED 0x1
|
|
#define DXF_POLYLINE_FLAG_3D_POLYLINE 0x8
|
|
#define DXF_POLYLINE_FLAG_3D_POLYMESH 0x10
|
|
#define DXF_POLYLINE_FLAG_POLYFACEMESH 0x40
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void DXFImporter::ParsePolyLine(DXF::LineReader& reader, DXF::FileData& output)
|
|
{
|
|
output.blocks.back().lines.push_back( std::shared_ptr<DXF::PolyLine>( new DXF::PolyLine() ) );
|
|
DXF::PolyLine& line = *output.blocks.back().lines.back();
|
|
|
|
unsigned int iguess = 0, vguess = 0;
|
|
while( !reader.End() && !reader.Is(0,"ENDSEC")) {
|
|
|
|
if (reader.Is(0,"VERTEX")) {
|
|
ParsePolyLineVertex(++reader,line);
|
|
if (reader.Is(0,"SEQEND")) {
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
switch(reader.GroupCode())
|
|
{
|
|
// flags --- important that we know whether it is a
|
|
// polyface mesh or 'just' a line.
|
|
case 70:
|
|
if (!line.flags) {
|
|
line.flags = reader.ValueAsSignedInt();
|
|
}
|
|
break;
|
|
|
|
// optional number of vertices
|
|
case 71:
|
|
vguess = reader.ValueAsSignedInt();
|
|
line.positions.reserve(vguess);
|
|
break;
|
|
|
|
// optional number of faces
|
|
case 72:
|
|
iguess = reader.ValueAsSignedInt();
|
|
line.indices.reserve(iguess);
|
|
break;
|
|
|
|
// 8 specifies the layer on which this line is placed on
|
|
case 8:
|
|
line.layer = reader.Value();
|
|
break;
|
|
}
|
|
|
|
reader++;
|
|
}
|
|
|
|
//if (!(line.flags & DXF_POLYLINE_FLAG_POLYFACEMESH)) {
|
|
// DefaultLogger::get()->warn((Formatter::format("DXF: polyline not currently supported: "),line.flags));
|
|
// output.blocks.back().lines.pop_back();
|
|
// return;
|
|
//}
|
|
|
|
if (vguess && line.positions.size() != vguess) {
|
|
DefaultLogger::get()->warn((Formatter::format("DXF: unexpected vertex count in polymesh: "),
|
|
line.positions.size(),", expected ", vguess
|
|
));
|
|
}
|
|
|
|
if (line.flags & DXF_POLYLINE_FLAG_POLYFACEMESH ) {
|
|
if (line.positions.size() < 3 || line.indices.size() < 3) {
|
|
DefaultLogger::get()->warn("DXF: not enough vertices for polymesh; ignoring");
|
|
output.blocks.back().lines.pop_back();
|
|
return;
|
|
}
|
|
|
|
// if these numbers are wrong, parsing might have gone wild.
|
|
// however, the docs state that applications are not required
|
|
// to set the 71 and 72 fields, respectively, to valid values.
|
|
// So just fire a warning.
|
|
if (iguess && line.counts.size() != iguess) {
|
|
DefaultLogger::get()->warn((Formatter::format("DXF: unexpected face count in polymesh: "),
|
|
line.counts.size(),", expected ", iguess
|
|
));
|
|
}
|
|
}
|
|
else if (!line.indices.size() && !line.counts.size()) {
|
|
// a polyline - so there are no indices yet.
|
|
size_t guess = line.positions.size() + (line.flags & DXF_POLYLINE_FLAG_CLOSED ? 1 : 0);
|
|
line.indices.reserve(guess);
|
|
|
|
line.counts.reserve(guess/2);
|
|
for (unsigned int i = 0; i < line.positions.size()/2; ++i) {
|
|
line.indices.push_back(i*2);
|
|
line.indices.push_back(i*2+1);
|
|
line.counts.push_back(2);
|
|
}
|
|
|
|
// closed polyline?
|
|
if (line.flags & DXF_POLYLINE_FLAG_CLOSED) {
|
|
line.indices.push_back(static_cast<unsigned int>(line.positions.size()-1));
|
|
line.indices.push_back(0);
|
|
line.counts.push_back(2);
|
|
}
|
|
}
|
|
}
|
|
|
|
#define DXF_VERTEX_FLAG_PART_OF_POLYFACE 0x80
|
|
#define DXF_VERTEX_FLAG_HAS_POSITIONS 0x40
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void DXFImporter::ParsePolyLineVertex(DXF::LineReader& reader, DXF::PolyLine& line)
|
|
{
|
|
unsigned int cnti = 0, flags = 0;
|
|
unsigned int indices[4];
|
|
|
|
aiVector3D out;
|
|
aiColor4D clr = AI_DXF_DEFAULT_COLOR;
|
|
|
|
while( !reader.End() ) {
|
|
|
|
if (reader.Is(0)) { // SEQEND or another VERTEX
|
|
break;
|
|
}
|
|
|
|
switch (reader.GroupCode())
|
|
{
|
|
case 8:
|
|
// layer to which the vertex belongs to - assume that
|
|
// this is always the layer the top-level polyline
|
|
// entity resides on as well.
|
|
if(reader.Value() != line.layer) {
|
|
DefaultLogger::get()->warn("DXF: expected vertex to be part of a polyface but the 0x128 flag isn't set");
|
|
}
|
|
break;
|
|
|
|
case 70:
|
|
flags = reader.ValueAsUnsignedInt();
|
|
break;
|
|
|
|
// VERTEX COORDINATES
|
|
case 10: out.x = reader.ValueAsFloat();break;
|
|
case 20: out.y = reader.ValueAsFloat();break;
|
|
case 30: out.z = reader.ValueAsFloat();break;
|
|
|
|
// POLYFACE vertex indices
|
|
case 71:
|
|
case 72:
|
|
case 73:
|
|
case 74:
|
|
if (cnti == 4) {
|
|
DefaultLogger::get()->warn("DXF: more than 4 indices per face not supported; ignoring");
|
|
break;
|
|
}
|
|
indices[cnti++] = reader.ValueAsUnsignedInt();
|
|
break;
|
|
|
|
// color
|
|
case 62:
|
|
clr = g_aclrDxfIndexColors[reader.ValueAsUnsignedInt() % AI_DXF_NUM_INDEX_COLORS];
|
|
break;
|
|
};
|
|
|
|
reader++;
|
|
}
|
|
|
|
if (line.flags & DXF_POLYLINE_FLAG_POLYFACEMESH && !(flags & DXF_VERTEX_FLAG_PART_OF_POLYFACE)) {
|
|
DefaultLogger::get()->warn("DXF: expected vertex to be part of a polyface but the 0x128 flag isn't set");
|
|
}
|
|
|
|
if (cnti) {
|
|
line.counts.push_back(cnti);
|
|
for (unsigned int i = 0; i < cnti; ++i) {
|
|
// IMPORTANT NOTE: POLYMESH indices are ONE-BASED
|
|
if (indices[i] == 0) {
|
|
DefaultLogger::get()->warn("DXF: invalid vertex index, indices are one-based.");
|
|
--line.counts.back();
|
|
continue;
|
|
}
|
|
line.indices.push_back(indices[i]-1);
|
|
}
|
|
}
|
|
else {
|
|
line.positions.push_back(out);
|
|
line.colors.push_back(clr);
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void DXFImporter::Parse3DFace(DXF::LineReader& reader, DXF::FileData& output)
|
|
{
|
|
// (note) this is also used for for parsing line entities, so we
|
|
// must handle the vertex_count == 2 case as well.
|
|
|
|
output.blocks.back().lines.push_back( std::shared_ptr<DXF::PolyLine>( new DXF::PolyLine() ) );
|
|
DXF::PolyLine& line = *output.blocks.back().lines.back();
|
|
|
|
aiVector3D vip[4];
|
|
aiColor4D clr = AI_DXF_DEFAULT_COLOR;
|
|
|
|
bool b[4] = {false,false,false,false};
|
|
while( !reader.End() ) {
|
|
|
|
// next entity with a groupcode == 0 is probably already the next vertex or polymesh entity
|
|
if (reader.GroupCode() == 0) {
|
|
break;
|
|
}
|
|
switch (reader.GroupCode())
|
|
{
|
|
|
|
// 8 specifies the layer
|
|
case 8:
|
|
line.layer = reader.Value();
|
|
break;
|
|
|
|
// x position of the first corner
|
|
case 10: vip[0].x = reader.ValueAsFloat();
|
|
b[2] = true;
|
|
break;
|
|
|
|
// y position of the first corner
|
|
case 20: vip[0].y = reader.ValueAsFloat();
|
|
b[2] = true;
|
|
break;
|
|
|
|
// z position of the first corner
|
|
case 30: vip[0].z = reader.ValueAsFloat();
|
|
b[2] = true;
|
|
break;
|
|
|
|
// x position of the second corner
|
|
case 11: vip[1].x = reader.ValueAsFloat();
|
|
b[3] = true;
|
|
break;
|
|
|
|
// y position of the second corner
|
|
case 21: vip[1].y = reader.ValueAsFloat();
|
|
b[3] = true;
|
|
break;
|
|
|
|
// z position of the second corner
|
|
case 31: vip[1].z = reader.ValueAsFloat();
|
|
b[3] = true;
|
|
break;
|
|
|
|
// x position of the third corner
|
|
case 12: vip[2].x = reader.ValueAsFloat();
|
|
b[0] = true;
|
|
break;
|
|
|
|
// y position of the third corner
|
|
case 22: vip[2].y = reader.ValueAsFloat();
|
|
b[0] = true;
|
|
break;
|
|
|
|
// z position of the third corner
|
|
case 32: vip[2].z = reader.ValueAsFloat();
|
|
b[0] = true;
|
|
break;
|
|
|
|
// x position of the fourth corner
|
|
case 13: vip[3].x = reader.ValueAsFloat();
|
|
b[1] = true;
|
|
break;
|
|
|
|
// y position of the fourth corner
|
|
case 23: vip[3].y = reader.ValueAsFloat();
|
|
b[1] = true;
|
|
break;
|
|
|
|
// z position of the fourth corner
|
|
case 33: vip[3].z = reader.ValueAsFloat();
|
|
b[1] = true;
|
|
break;
|
|
|
|
// color
|
|
case 62:
|
|
clr = g_aclrDxfIndexColors[reader.ValueAsUnsignedInt() % AI_DXF_NUM_INDEX_COLORS];
|
|
break;
|
|
};
|
|
|
|
++reader;
|
|
}
|
|
|
|
// the fourth corner may even be identical to the third,
|
|
// in this case we treat it as if it didn't exist.
|
|
if (vip[3] == vip[2]) {
|
|
b[1] = false;
|
|
}
|
|
|
|
// sanity checks to see if we got something meaningful
|
|
if ((b[1] && !b[0]) || !b[2] || !b[3]) {
|
|
DefaultLogger::get()->warn("DXF: unexpected vertex setup in 3DFACE/LINE/FACE entity; ignoring");
|
|
output.blocks.back().lines.pop_back();
|
|
return;
|
|
}
|
|
|
|
const unsigned int cnt = (2+(b[0]?1:0)+(b[1]?1:0));
|
|
line.counts.push_back(cnt);
|
|
|
|
for (unsigned int i = 0; i < cnt; ++i) {
|
|
line.indices.push_back(static_cast<unsigned int>(line.positions.size()));
|
|
line.positions.push_back(vip[i]);
|
|
line.colors.push_back(clr);
|
|
}
|
|
}
|
|
|
|
#endif // !! ASSIMP_BUILD_NO_DXF_IMPORTER
|
|
|