v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

DXF-Importer: some small review findings.

pull/2235/head
Kim Kulling 2018-11-21 22:00:11 +01:00
parent f00154802c
commit a24502577f
3 changed files with 94 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
code/DXFHelper.h
View File

@ -55,21 +55,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/DefaultLogger.hpp> #include <assimp/DefaultLogger.hpp>
namespace Assimp { namespace Assimp {
namespace DXF { namespace DXF {
// read pairs of lines, parse group code and value and provide utilities // read pairs of lines, parse group code and value and provide utilities
// to convert the data to the target data type. // to convert the data to the target data type.
class LineReader // do NOT skip empty lines. In DXF files, they count as valid data.
{ class LineReader {
public: public:
LineReader(StreamReaderLE& reader) LineReader(StreamReaderLE& reader)
// do NOT skip empty lines. In DXF files, they count as valid data.
: splitter(reader,false,true) : splitter(reader,false,true)
, groupcode( 0 ) , groupcode( 0 )
, value() , value()
, end() , end() {
{ // empty
} }
// ----------------------------------------- // -----------------------------------------
@ -112,8 +110,6 @@ public:
return fast_atof(value.c_str()); return fast_atof(value.c_str());
} }
public:
// ----------------------------------------- // -----------------------------------------
/** pseudo-iterator increment to advance to the next (groupcode/value) pair */ /** pseudo-iterator increment to advance to the next (groupcode/value) pair */
LineReader& operator++() { LineReader& operator++() {
@ -168,14 +164,12 @@ private:
int end; int end;
}; };
// represents a POLYLINE or a LWPOLYLINE. or even a 3DFACE The data is converted as needed. // represents a POLYLINE or a LWPOLYLINE. or even a 3DFACE The data is converted as needed.
struct PolyLine struct PolyLine {
{
PolyLine() PolyLine()
: flags() : flags() {
{} // empty
}
std::vector<aiVector3D> positions; std::vector<aiVector3D> positions;
std::vector<aiColor4D> colors; std::vector<aiColor4D> colors;
@ -187,14 +181,15 @@ struct PolyLine
std::string desc; std::string desc;
}; };
// reference to a BLOCK. Specifies its own coordinate system. // reference to a BLOCK. Specifies its own coordinate system.
struct InsertBlock struct InsertBlock {
{
InsertBlock() InsertBlock()
: scale(1.f,1.f,1.f) : pos()
, scale(1.f,1.f,1.f)
, angle() , angle()
{} , name() {
// empty
}
aiVector3D pos; aiVector3D pos;
aiVector3D scale; aiVector3D scale;

121
code/DXFLoader.cpp
View File

@ -71,8 +71,7 @@ const aiColor4D AI_DXF_DEFAULT_COLOR(aiColor4D(0.6f, 0.6f, 0.6f, 0.6f));
// color indices for DXF - 16 are supported, the table is // color indices for DXF - 16 are supported, the table is
// taken directly from the DXF spec. // taken directly from the DXF spec.
static aiColor4D g_aclrDxfIndexColors[] = static aiColor4D g_aclrDxfIndexColors[] = {
{
aiColor4D (0.6f, 0.6f, 0.6f, 1.0f), aiColor4D (0.6f, 0.6f, 0.6f, 1.0f),
aiColor4D (1.0f, 0.0f, 0.0f, 1.0f), // red aiColor4D (1.0f, 0.0f, 0.0f, 1.0f), // red
aiColor4D (0.0f, 1.0f, 0.0f, 1.0f), // green aiColor4D (0.0f, 1.0f, 0.0f, 1.0f), // green
@ -93,6 +92,11 @@ static aiColor4D g_aclrDxfIndexColors[] =
#define AI_DXF_NUM_INDEX_COLORS (sizeof(g_aclrDxfIndexColors)/sizeof(g_aclrDxfIndexColors[0])) #define AI_DXF_NUM_INDEX_COLORS (sizeof(g_aclrDxfIndexColors)/sizeof(g_aclrDxfIndexColors[0]))
#define AI_DXF_ENTITIES_MAGIC_BLOCK "$ASSIMP_ENTITIES_MAGIC" #define AI_DXF_ENTITIES_MAGIC_BLOCK "$ASSIMP_ENTITIES_MAGIC"
static const int GroupCode_Name = 2;
static const int GroupCode_XComp = 10;
static const int GroupCode_YComp = 20;
static const int GroupCode_ZComp = 30;
static const aiImporterDesc desc = { static const aiImporterDesc desc = {
"Drawing Interchange Format (DXF) Importer", "Drawing Interchange Format (DXF) Importer",
"", "",
@ -123,12 +127,12 @@ DXFImporter::~DXFImporter() {
// Returns whether the class can handle the format of the given file. // Returns whether the class can handle the format of the given file.
bool DXFImporter::CanRead( const std::string& filename, IOSystem* pIOHandler, bool checkSig ) const { bool DXFImporter::CanRead( const std::string& filename, IOSystem* pIOHandler, bool checkSig ) const {
const std::string& extension = GetExtension( filename ); const std::string& extension = GetExtension( filename );
if ( extension == "dxf" ) { if ( extension == desc.mFileExtensions ) {
return true; return true;
} }
if ( extension.empty() || checkSig ) { if ( extension.empty() || checkSig ) {
static const char *pTokens[] = { "SECTION", "HEADER", "ENDSEC", "BLOCKS" }; const char *pTokens[] = { "SECTION", "HEADER", "ENDSEC", "BLOCKS" };
return BaseImporter::SearchFileHeaderForToken(pIOHandler, filename, pTokens, 4, 32 ); return BaseImporter::SearchFileHeaderForToken(pIOHandler, filename, pTokens, 4, 32 );
} }
@ -137,29 +141,25 @@ bool DXFImporter::CanRead( const std::string& filename, IOSystem* pIOHandler, bo
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Get a list of all supported file extensions // Get a list of all supported file extensions
const aiImporterDesc* DXFImporter::GetInfo () const const aiImporterDesc* DXFImporter::GetInfo () const {
{
return &desc; return &desc;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Imports the given file into the given scene structure. // Imports the given file into the given scene structure.
void DXFImporter::InternReadFile( const std::string& pFile, void DXFImporter::InternReadFile( const std::string& filename, aiScene* pScene, IOSystem* pIOHandler) {
aiScene* pScene, std::shared_ptr<IOStream> file = std::shared_ptr<IOStream>( pIOHandler->Open( filename) );
IOSystem* pIOHandler)
{
std::shared_ptr<IOStream> file = std::shared_ptr<IOStream>( pIOHandler->Open( pFile) );
// Check whether we can read the file // Check whether we can read the file
if( file.get() == NULL) { if( file.get() == nullptr ) {
throw DeadlyImportError( "Failed to open DXF file " + pFile + ""); throw DeadlyImportError( "Failed to open DXF file " + filename + "");
} }
// check whether this is a binaray DXF file - we can't read binary DXF files :-( // Check whether this is a binary DXF file - we can't read binary DXF files :-(
char buff[AI_DXF_BINARY_IDENT_LEN+1] = {0}; char buff[AI_DXF_BINARY_IDENT_LEN+1] = {0};
file->Read(buff,AI_DXF_BINARY_IDENT_LEN,1); file->Read(buff,AI_DXF_BINARY_IDENT_LEN,1);
if (!strncmp(AI_DXF_BINARY_IDENT.c_str(),buff,AI_DXF_BINARY_IDENT_LEN)) { if (0 == strncmp(AI_DXF_BINARY_IDENT.c_str(),buff,AI_DXF_BINARY_IDENT_LEN)) {
throw DeadlyImportError("DXF: Binary files are not supported at the moment"); throw DeadlyImportError("DXF: Binary files are not supported at the moment");
} }
@ -228,13 +228,11 @@ void DXFImporter::InternReadFile( const std::string& pFile,
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output) void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output) {
{
// the process of resolving all the INSERT statements can grow the // the process of resolving all the INSERT statements can grow the
// poly-count excessively, so log the original number. // poly-count excessively, so log the original number.
// XXX Option to import blocks as separate nodes? // XXX Option to import blocks as separate nodes?
if (!DefaultLogger::isNullLogger()) { if (!DefaultLogger::isNullLogger()) {
unsigned int vcount = 0, icount = 0; unsigned int vcount = 0, icount = 0;
for (const DXF::Block& bl : output.blocks) { for (const DXF::Block& bl : output.blocks) {
for (std::shared_ptr<const DXF::PolyLine> pl : bl.lines) { for (std::shared_ptr<const DXF::PolyLine> pl : bl.lines) {
@ -295,7 +293,7 @@ void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output)
} }
} }
if (!pScene->mNumMeshes) { if ( 0 == pScene->mNumMeshes) {
throw DeadlyImportError("DXF: this file contains no 3d data"); throw DeadlyImportError("DXF: this file contains no 3d data");
} }
@ -368,8 +366,7 @@ void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void DXFImporter::ExpandBlockReferences(DXF::Block& bl,const DXF::BlockMap& blocks_by_name) void DXFImporter::ExpandBlockReferences(DXF::Block& bl,const DXF::BlockMap& blocks_by_name) {
{
for (const DXF::InsertBlock& insert : bl.insertions) { for (const DXF::InsertBlock& insert : bl.insertions) {
// first check if the referenced blocks exists ... // first check if the referenced blocks exists ...
@ -409,8 +406,7 @@ void DXFImporter::ExpandBlockReferences(DXF::Block& bl,const DXF::BlockMap& bloc
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void DXFImporter::GenerateMaterials(aiScene* pScene, DXF::FileData& /*output*/) void DXFImporter::GenerateMaterials(aiScene* pScene, DXF::FileData& /*output*/) {
{
// generate an almost-white default material. Reason: // generate an almost-white default material. Reason:
// the default vertex color is GREY, so we are // the default vertex color is GREY, so we are
// already at Assimp's usual default color. // already at Assimp's usual default color.
@ -435,8 +431,7 @@ void DXFImporter::GenerateMaterials(aiScene* pScene, DXF::FileData& /*output*/)
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void DXFImporter::GenerateHierarchy(aiScene* pScene, DXF::FileData& /*output*/) 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. // generate the output scene graph, which is just the root node with a single child for each layer.
pScene->mRootNode = new aiNode(); pScene->mRootNode = new aiNode();
pScene->mRootNode->mName.Set("<DXF_ROOT>"); pScene->mRootNode->mName.Set("<DXF_ROOT>");
@ -490,17 +485,17 @@ void DXFImporter::ParseBlock(DXF::LineReader& reader, DXF::FileData& output) {
while( !reader.End() && !reader.Is(0,"ENDBLK")) { while( !reader.End() && !reader.Is(0,"ENDBLK")) {
switch(reader.GroupCode()) { switch(reader.GroupCode()) {
case 2: case GroupCode_Name:
block.name = reader.Value(); block.name = reader.Value();
break; break;
case 10: case GroupCode_XComp:
block.base.x = reader.ValueAsFloat(); block.base.x = reader.ValueAsFloat();
break; break;
case 20: case GroupCode_YComp:
block.base.y = reader.ValueAsFloat(); block.base.y = reader.ValueAsFloat();
break; break;
case 30: case GroupCode_ZComp:
block.base.z = reader.ValueAsFloat(); block.base.z = reader.ValueAsFloat();
break; break;
} }
@ -527,9 +522,8 @@ void DXFImporter::ParseBlock(DXF::LineReader& reader, DXF::FileData& output) {
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void DXFImporter::ParseEntities(DXF::LineReader& reader, DXF::FileData& output) void DXFImporter::ParseEntities(DXF::LineReader& reader, DXF::FileData& output) {
{ // Push a new block onto the stack.
// push a new block onto the stack.
output.blocks.push_back( DXF::Block() ); output.blocks.push_back( DXF::Block() );
DXF::Block& block = output.blocks.back(); DXF::Block& block = output.blocks.back();
@ -559,27 +553,25 @@ void DXFImporter::ParseEntities(DXF::LineReader& reader, DXF::FileData& output)
" inserted blocks in ENTITIES" ); " inserted blocks in ENTITIES" );
} }
void DXFImporter::ParseInsertion(DXF::LineReader& reader, DXF::FileData& output) void DXFImporter::ParseInsertion(DXF::LineReader& reader, DXF::FileData& output) {
{
output.blocks.back().insertions.push_back( DXF::InsertBlock() ); output.blocks.back().insertions.push_back( DXF::InsertBlock() );
DXF::InsertBlock& bl = output.blocks.back().insertions.back(); DXF::InsertBlock& bl = output.blocks.back().insertions.back();
while( !reader.End() && !reader.Is(0)) { while( !reader.End() && !reader.Is(0)) {
switch(reader.GroupCode()) switch(reader.GroupCode()) {
{
// name of referenced block // name of referenced block
case 2: case GroupCode_Name:
bl.name = reader.Value(); bl.name = reader.Value();
break; break;
// translation // translation
case 10: case GroupCode_XComp:
bl.pos.x = reader.ValueAsFloat(); bl.pos.x = reader.ValueAsFloat();
break; break;
case 20: case GroupCode_YComp:
bl.pos.y = reader.ValueAsFloat(); bl.pos.y = reader.ValueAsFloat();
break; break;
case 30: case GroupCode_ZComp:
bl.pos.z = reader.ValueAsFloat(); bl.pos.z = reader.ValueAsFloat();
break; break;
@ -706,8 +698,7 @@ void DXFImporter::ParsePolyLine(DXF::LineReader& reader, DXF::FileData& output)
#define DXF_VERTEX_FLAG_HAS_POSITIONS 0x40 #define DXF_VERTEX_FLAG_HAS_POSITIONS 0x40
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void DXFImporter::ParsePolyLineVertex(DXF::LineReader& reader, DXF::PolyLine& line) void DXFImporter::ParsePolyLineVertex(DXF::LineReader& reader, DXF::PolyLine& line) {
{
unsigned int cnti = 0, flags = 0; unsigned int cnti = 0, flags = 0;
unsigned int indices[4]; unsigned int indices[4];
@ -720,8 +711,7 @@ void DXFImporter::ParsePolyLineVertex(DXF::LineReader& reader, DXF::PolyLine& li
break; break;
} }
switch (reader.GroupCode()) switch (reader.GroupCode()) {
{
case 8: case 8:
// layer to which the vertex belongs to - assume that // layer to which the vertex belongs to - assume that
// this is always the layer the top-level poly-line // this is always the layer the top-level poly-line
@ -736,15 +726,15 @@ void DXFImporter::ParsePolyLineVertex(DXF::LineReader& reader, DXF::PolyLine& li
break; break;
// VERTEX COORDINATES // VERTEX COORDINATES
case 10: case GroupCode_XComp:
out.x = reader.ValueAsFloat(); out.x = reader.ValueAsFloat();
break; break;
case 20: case GroupCode_YComp:
out.y = reader.ValueAsFloat(); out.y = reader.ValueAsFloat();
break; break;
case 30: case GroupCode_ZComp:
out.z = reader.ValueAsFloat(); out.z = reader.ValueAsFloat();
break; break;
@ -780,6 +770,7 @@ void DXFImporter::ParsePolyLineVertex(DXF::LineReader& reader, DXF::PolyLine& li
if (indices[i] == 0) { if (indices[i] == 0) {
ASSIMP_LOG_WARN("DXF: invalid vertex index, indices are one-based."); ASSIMP_LOG_WARN("DXF: invalid vertex index, indices are one-based.");
--line.counts.back(); --line.counts.back();
// Workaround to fix issue 2229
if (line.counts.back() == 0) { if (line.counts.back() == 0) {
line.counts.pop_back(); line.counts.pop_back();
} }
@ -821,62 +812,74 @@ void DXFImporter::Parse3DFace(DXF::LineReader& reader, DXF::FileData& output)
break; break;
// x position of the first corner // x position of the first corner
case 10: vip[0].x = reader.ValueAsFloat(); case 10:
vip[0].x = reader.ValueAsFloat();
b[2] = true; b[2] = true;
break; break;
// y position of the first corner // y position of the first corner
case 20: vip[0].y = reader.ValueAsFloat(); case 20:
vip[0].y = reader.ValueAsFloat();
b[2] = true; b[2] = true;
break; break;
// z position of the first corner // z position of the first corner
case 30: vip[0].z = reader.ValueAsFloat(); case 30:
vip[0].z = reader.ValueAsFloat();
b[2] = true; b[2] = true;
break; break;
// x position of the second corner // x position of the second corner
case 11: vip[1].x = reader.ValueAsFloat(); case 11:
vip[1].x = reader.ValueAsFloat();
b[3] = true; b[3] = true;
break; break;
// y position of the second corner // y position of the second corner
case 21: vip[1].y = reader.ValueAsFloat(); case 21:
vip[1].y = reader.ValueAsFloat();
b[3] = true; b[3] = true;
break; break;
// z position of the second corner // z position of the second corner
case 31: vip[1].z = reader.ValueAsFloat(); case 31:
vip[1].z = reader.ValueAsFloat();
b[3] = true; b[3] = true;
break; break;
// x position of the third corner // x position of the third corner
case 12: vip[2].x = reader.ValueAsFloat(); case 12:
vip[2].x = reader.ValueAsFloat();
b[0] = true; b[0] = true;
break; break;
// y position of the third corner // y position of the third corner
case 22: vip[2].y = reader.ValueAsFloat(); case 22:
vip[2].y = reader.ValueAsFloat();
b[0] = true; b[0] = true;
break; break;
// z position of the third corner // z position of the third corner
case 32: vip[2].z = reader.ValueAsFloat(); case 32:
vip[2].z = reader.ValueAsFloat();
b[0] = true; b[0] = true;
break; break;
// x position of the fourth corner // x position of the fourth corner
case 13: vip[3].x = reader.ValueAsFloat(); case 13:
vip[3].x = reader.ValueAsFloat();
b[1] = true; b[1] = true;
break; break;
// y position of the fourth corner // y position of the fourth corner
case 23: vip[3].y = reader.ValueAsFloat(); case 23:
vip[3].y = reader.ValueAsFloat();
b[1] = true; b[1] = true;
break; break;
// z position of the fourth corner // z position of the fourth corner
case 33: vip[3].z = reader.ValueAsFloat(); case 33:
vip[3].z = reader.ValueAsFloat();
b[1] = true; b[1] = true;
break; break;

15
code/DXFLoader.h
View File

@ -50,8 +50,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <map> #include <map>
namespace Assimp { namespace Assimp {
namespace DXF {
// Forward declarations
namespace DXF {
class LineReader; class LineReader;
struct FileData; struct FileData;
struct PolyLine; struct PolyLine;
@ -59,15 +60,13 @@ namespace Assimp {
struct InsertBlock; struct InsertBlock;
typedef std::map<std::string, const DXF::Block*> BlockMap; typedef std::map<std::string, const DXF::Block*> BlockMap;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** DXF importer implementation. /**
* * @brief DXF importer implementation.
*/ */
class DXFImporter : public BaseImporter class DXFImporter : public BaseImporter {
{
public: public:
DXFImporter(); DXFImporter();
~DXFImporter(); ~DXFImporter();