/*

---------------------------------------------------------------------------

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

Copyright (c) 2006-2025, 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 "DXFHelper.h"

#include "PostProcessing/ConvertToLHProcess.h"

#include <assimp/ParsingUtils.h>

#include <assimp/fast_atof.h>

#include <assimp/IOSystem.hpp>

#include <assimp/scene.h>

#include <assimp/importerdesc.h>

#include <numeric>

#include <utility>

using namespace Assimp;

// AutoCAD Binary DXF<CR><LF><SUB><NULL>

static constexpr char AI_DXF_BINARY_IDENT[] = "AutoCAD Binary DXF\r\n\x1a";

static constexpr size_t AI_DXF_BINARY_IDENT_LEN = sizeof AI_DXF_BINARY_IDENT;

// default vertex color that all uncolored vertices will receive

static const aiColor4D AI_DXF_DEFAULT_COLOR(aiColor4D(0.6f, 0.6f, 0.6f, 0.6f));

// color indices for DXF - 256 are supported, the table is

// taken directly from the AutoCad Index (ACI) table

// https://gohtx.com/acadcolors.php

//STH 2024-0126

static const aiColor4D g_aclrDxfIndexColors[256] = {

    aiColor4D (0.0f, 0.0f ,0.0f, 1.0f), //dxf color code 0

    aiColor4D (1.0f, 0.0f ,0.0f, 1.0f), //dxf color code 1

    aiColor4D (1.0f, 1.0f ,0.0f, 1.0f), //dxf color code 2

    aiColor4D (0.0f, 1.0f ,0.0f, 1.0f), //dxf color code 3

    aiColor4D (0.0f, 1.0f ,1.0f, 1.0f), //dxf color code 4

    aiColor4D (0.0f, 0.0f ,1.0f, 1.0f), //dxf color code 5

    aiColor4D (1.0f, 0.0f ,1.0f, 1.0f), //dxf color code 6

    aiColor4D (1.0f, 1.0f ,1.0f, 1.0f), //dxf color code 7

    aiColor4D (0.3f, 0.3f ,0.3f, 1.0f), //dxf color code 8

    aiColor4D (0.5f, 0.5f ,0.5f, 1.0f), //dxf color code 9

    aiColor4D (1.0f, 0.0f ,0.0f, 1.0f), //dxf color code 10

    aiColor4D (1.0f, 0.7f ,0.7f, 1.0f), //dxf color code 11

    aiColor4D (0.7f, 0.0f ,0.0f, 1.0f), //dxf color code 12

    aiColor4D (0.7f, 0.5f ,0.5f, 1.0f), //dxf color code 13

    aiColor4D (0.5f, 0.0f ,0.0f, 1.0f), //dxf color code 14

    aiColor4D (0.5f, 0.3f ,0.3f, 1.0f), //dxf color code 15

    aiColor4D (0.4f, 0.0f ,0.0f, 1.0f), //dxf color code 16

    aiColor4D (0.4f, 0.3f ,0.3f, 1.0f), //dxf color code 17

    aiColor4D (0.3f, 0.0f ,0.0f, 1.0f), //dxf color code 18

    aiColor4D (0.3f, 0.2f ,0.2f, 1.0f), //dxf color code 19

    aiColor4D (1.0f, 0.2f ,0.0f, 1.0f), //dxf color code 20

    aiColor4D (1.0f, 0.7f ,0.7f, 1.0f), //dxf color code 21

    aiColor4D (0.7f, 0.2f ,0.0f, 1.0f), //dxf color code 22

    aiColor4D (0.7f, 0.6f ,0.5f, 1.0f), //dxf color code 23

    aiColor4D (0.5f, 0.1f ,0.0f, 1.0f), //dxf color code 24

    aiColor4D (0.5f, 0.4f ,0.3f, 1.0f), //dxf color code 25

    aiColor4D (0.4f, 0.1f ,0.0f, 1.0f), //dxf color code 26

    aiColor4D (0.4f, 0.3f ,0.3f, 1.0f), //dxf color code 27

    aiColor4D (0.3f, 0.1f ,0.0f, 1.0f), //dxf color code 28

    aiColor4D (0.3f, 0.2f ,0.2f, 1.0f), //dxf color code 29

    aiColor4D (1.0f, 0.5f ,0.0f, 1.0f), //dxf color code 30

    aiColor4D (1.0f, 0.8f ,0.7f, 1.0f), //dxf color code 31

    aiColor4D (0.7f, 0.4f ,0.0f, 1.0f), //dxf color code 32

    aiColor4D (0.7f, 0.6f ,0.5f, 1.0f), //dxf color code 33

    aiColor4D (0.5f, 0.3f ,0.0f, 1.0f), //dxf color code 34

    aiColor4D (0.5f, 0.4f ,0.3f, 1.0f), //dxf color code 35

    aiColor4D (0.4f, 0.2f ,0.0f, 1.0f), //dxf color code 36

    aiColor4D (0.4f, 0.3f ,0.3f, 1.0f), //dxf color code 37

    aiColor4D (0.3f, 0.2f ,0.0f, 1.0f), //dxf color code 38

    aiColor4D (0.3f, 0.3f ,0.2f, 1.0f), //dxf color code 39

    aiColor4D (1.0f, 0.7f ,0.0f, 1.0f), //dxf color code 40

    aiColor4D (1.0f, 0.9f ,0.7f, 1.0f), //dxf color code 41

    aiColor4D (0.7f, 0.6f ,0.0f, 1.0f), //dxf color code 42

    aiColor4D (0.7f, 0.7f ,0.5f, 1.0f), //dxf color code 43

    aiColor4D (0.5f, 0.4f ,0.0f, 1.0f), //dxf color code 44

    aiColor4D (0.5f, 0.5f ,0.3f, 1.0f), //dxf color code 45

    aiColor4D (0.4f, 0.3f ,0.0f, 1.0f), //dxf color code 46

    aiColor4D (0.4f, 0.4f ,0.3f, 1.0f), //dxf color code 47

    aiColor4D (0.3f, 0.2f ,0.0f, 1.0f), //dxf color code 48

    aiColor4D (0.3f, 0.3f ,0.2f, 1.0f), //dxf color code 49

    aiColor4D (1.0f, 1.0f ,0.0f, 1.0f), //dxf color code 50

    aiColor4D (1.0f, 1.0f ,0.7f, 1.0f), //dxf color code 51

    aiColor4D (0.7f, 0.7f ,0.0f, 1.0f), //dxf color code 52

    aiColor4D (0.7f, 0.7f ,0.5f, 1.0f), //dxf color code 53

    aiColor4D (0.5f, 0.5f ,0.0f, 1.0f), //dxf color code 54

    aiColor4D (0.5f, 0.5f ,0.3f, 1.0f), //dxf color code 55

    aiColor4D (0.4f, 0.4f ,0.0f, 1.0f), //dxf color code 56

    aiColor4D (0.4f, 0.4f ,0.3f, 1.0f), //dxf color code 57

    aiColor4D (0.3f, 0.3f ,0.0f, 1.0f), //dxf color code 58

    aiColor4D (0.3f, 0.3f ,0.2f, 1.0f), //dxf color code 59

    aiColor4D (0.7f, 1.0f ,0.0f, 1.0f), //dxf color code 60

    aiColor4D (0.9f, 1.0f ,0.7f, 1.0f), //dxf color code 61

    aiColor4D (0.6f, 0.7f ,0.0f, 1.0f), //dxf color code 62

    aiColor4D (0.7f, 0.7f ,0.5f, 1.0f), //dxf color code 63

    aiColor4D (0.4f, 0.5f ,0.0f, 1.0f), //dxf color code 64

    aiColor4D (0.5f, 0.5f ,0.3f, 1.0f), //dxf color code 65

    aiColor4D (0.3f, 0.4f ,0.0f, 1.0f), //dxf color code 66

    aiColor4D (0.4f, 0.4f ,0.3f, 1.0f), //dxf color code 67

    aiColor4D (0.2f, 0.3f ,0.0f, 1.0f), //dxf color code 68

    aiColor4D (0.3f, 0.3f ,0.2f, 1.0f), //dxf color code 69

    aiColor4D (0.5f, 1.0f ,0.0f, 1.0f), //dxf color code 70

    aiColor4D (0.8f, 1.0f ,0.7f, 1.0f), //dxf color code 71

    aiColor4D (0.4f, 0.7f ,0.0f, 1.0f), //dxf color code 72

    aiColor4D (0.6f, 0.7f ,0.5f, 1.0f), //dxf color code 73

    aiColor4D (0.3f, 0.5f ,0.0f, 1.0f), //dxf color code 74

    aiColor4D (0.4f, 0.5f ,0.3f, 1.0f), //dxf color code 75

    aiColor4D (0.2f, 0.4f ,0.0f, 1.0f), //dxf color code 76

    aiColor4D (0.3f, 0.4f ,0.3f, 1.0f), //dxf color code 77

    aiColor4D (0.2f, 0.3f ,0.0f, 1.0f), //dxf color code 78

    aiColor4D (0.3f, 0.3f ,0.2f, 1.0f), //dxf color code 79

    aiColor4D (0.2f, 1.0f ,0.0f, 1.0f), //dxf color code 80

    aiColor4D (0.7f, 1.0f ,0.7f, 1.0f), //dxf color code 81

    aiColor4D (0.2f, 0.7f ,0.0f, 1.0f), //dxf color code 82

    aiColor4D (0.6f, 0.7f ,0.5f, 1.0f), //dxf color code 83

    aiColor4D (0.1f, 0.5f ,0.0f, 1.0f), //dxf color code 84

    aiColor4D (0.4f, 0.5f ,0.3f, 1.0f), //dxf color code 85

    aiColor4D (0.1f, 0.4f ,0.0f, 1.0f), //dxf color code 86

    aiColor4D (0.3f, 0.4f ,0.3f, 1.0f), //dxf color code 87

    aiColor4D (0.1f, 0.3f ,0.0f, 1.0f), //dxf color code 88

    aiColor4D (0.2f, 0.3f ,0.2f, 1.0f), //dxf color code 89

    aiColor4D (0.0f, 1.0f ,0.0f, 1.0f), //dxf color code 90

    aiColor4D (0.7f, 1.0f ,0.7f, 1.0f), //dxf color code 91

    aiColor4D (0.0f, 0.7f ,0.0f, 1.0f), //dxf color code 92

    aiColor4D (0.5f, 0.7f ,0.5f, 1.0f), //dxf color code 93

    aiColor4D (0.0f, 0.5f ,0.0f, 1.0f), //dxf color code 94

    aiColor4D (0.3f, 0.5f ,0.3f, 1.0f), //dxf color code 95

    aiColor4D (0.0f, 0.4f ,0.0f, 1.0f), //dxf color code 96

    aiColor4D (0.3f, 0.4f ,0.3f, 1.0f), //dxf color code 97

    aiColor4D (0.0f, 0.3f ,0.0f, 1.0f), //dxf color code 98

    aiColor4D (0.2f, 0.3f ,0.2f, 1.0f), //dxf color code 99

    aiColor4D (0.0f, 1.0f ,0.2f, 1.0f), //dxf color code 100

    aiColor4D (0.7f, 1.0f ,0.7f, 1.0f), //dxf color code 101

    aiColor4D (0.0f, 0.7f ,0.2f, 1.0f), //dxf color code 102

    aiColor4D (0.5f, 0.7f ,0.6f, 1.0f), //dxf color code 103

    aiColor4D (0.0f, 0.5f ,0.1f, 1.0f), //dxf color code 104

    aiColor4D (0.3f, 0.5f ,0.4f, 1.0f), //dxf color code 105

    aiColor4D (0.0f, 0.4f ,0.1f, 1.0f), //dxf color code 106

    aiColor4D (0.3f, 0.4f ,0.3f, 1.0f), //dxf color code 107

    aiColor4D (0.0f, 0.3f ,0.1f, 1.0f), //dxf color code 108

    aiColor4D (0.2f, 0.3f ,0.2f, 1.0f), //dxf color code 109

    aiColor4D (0.0f, 1.0f ,0.5f, 1.0f), //dxf color code 110

    aiColor4D (0.7f, 1.0f ,0.8f, 1.0f), //dxf color code 111

    aiColor4D (0.0f, 0.7f ,0.4f, 1.0f), //dxf color code 112

    aiColor4D (0.5f, 0.7f ,0.6f, 1.0f), //dxf color code 113

    aiColor4D (0.0f, 0.5f ,0.3f, 1.0f), //dxf color code 114

    aiColor4D (0.3f, 0.5f ,0.4f, 1.0f), //dxf color code 115

    aiColor4D (0.0f, 0.4f ,0.2f, 1.0f), //dxf color code 116

    aiColor4D (0.3f, 0.4f ,0.3f, 1.0f), //dxf color code 117

    aiColor4D (0.0f, 0.3f ,0.2f, 1.0f), //dxf color code 118

    aiColor4D (0.2f, 0.3f ,0.3f, 1.0f), //dxf color code 119

    aiColor4D (0.0f, 1.0f ,0.7f, 1.0f), //dxf color code 120

    aiColor4D (0.7f, 1.0f ,0.9f, 1.0f), //dxf color code 121

    aiColor4D (0.0f, 0.7f ,0.6f, 1.0f), //dxf color code 122

    aiColor4D (0.5f, 0.7f ,0.7f, 1.0f), //dxf color code 123

    aiColor4D (0.0f, 0.5f ,0.4f, 1.0f), //dxf color code 124

    aiColor4D (0.3f, 0.5f ,0.5f, 1.0f), //dxf color code 125

    aiColor4D (0.0f, 0.4f ,0.3f, 1.0f), //dxf color code 126

    aiColor4D (0.3f, 0.4f ,0.4f, 1.0f), //dxf color code 127

    aiColor4D (0.0f, 0.3f ,0.2f, 1.0f), //dxf color code 128

    aiColor4D (0.2f, 0.3f ,0.3f, 1.0f), //dxf color code 129

    aiColor4D (0.0f, 1.0f ,1.0f, 1.0f), //dxf color code 130

    aiColor4D (0.7f, 1.0f ,1.0f, 1.0f), //dxf color code 131

    aiColor4D (0.0f, 0.7f ,0.7f, 1.0f), //dxf color code 132

    aiColor4D (0.5f, 0.7f ,0.7f, 1.0f), //dxf color code 133

    aiColor4D (0.0f, 0.5f ,0.5f, 1.0f), //dxf color code 134

    aiColor4D (0.3f, 0.5f ,0.5f, 1.0f), //dxf color code 135

    aiColor4D (0.0f, 0.4f ,0.4f, 1.0f), //dxf color code 136

    aiColor4D (0.3f, 0.4f ,0.4f, 1.0f), //dxf color code 137

    aiColor4D (0.0f, 0.3f ,0.3f, 1.0f), //dxf color code 138

    aiColor4D (0.2f, 0.3f ,0.3f, 1.0f), //dxf color code 139

    aiColor4D (0.0f, 0.7f ,1.0f, 1.0f), //dxf color code 140

    aiColor4D (0.7f, 0.9f ,1.0f, 1.0f), //dxf color code 141

    aiColor4D (0.0f, 0.6f ,0.7f, 1.0f), //dxf color code 142

    aiColor4D (0.5f, 0.7f ,0.7f, 1.0f), //dxf color code 143

    aiColor4D (0.0f, 0.4f ,0.5f, 1.0f), //dxf color code 144

    aiColor4D (0.3f, 0.5f ,0.5f, 1.0f), //dxf color code 145

    aiColor4D (0.0f, 0.3f ,0.4f, 1.0f), //dxf color code 146

    aiColor4D (0.3f, 0.4f ,0.4f, 1.0f), //dxf color code 147

    aiColor4D (0.0f, 0.2f ,0.3f, 1.0f), //dxf color code 148

    aiColor4D (0.2f, 0.3f ,0.3f, 1.0f), //dxf color code 149

    aiColor4D (0.0f, 0.5f ,1.0f, 1.0f), //dxf color code 150

    aiColor4D (0.7f, 0.8f ,1.0f, 1.0f), //dxf color code 151

    aiColor4D (0.0f, 0.4f ,0.7f, 1.0f), //dxf color code 152

    aiColor4D (0.5f, 0.6f ,0.7f, 1.0f), //dxf color code 153

    aiColor4D (0.0f, 0.3f ,0.5f, 1.0f), //dxf color code 154

    aiColor4D (0.3f, 0.4f ,0.5f, 1.0f), //dxf color code 155

    aiColor4D (0.0f, 0.2f ,0.4f, 1.0f), //dxf color code 156

    aiColor4D (0.3f, 0.3f ,0.4f, 1.0f), //dxf color code 157

    aiColor4D (0.0f, 0.2f ,0.3f, 1.0f), //dxf color code 158

    aiColor4D (0.2f, 0.3f ,0.3f, 1.0f), //dxf color code 159

    aiColor4D (0.0f, 0.2f ,1.0f, 1.0f), //dxf color code 160

    aiColor4D (0.7f, 0.7f ,1.0f, 1.0f), //dxf color code 161

    aiColor4D (0.0f, 0.2f ,0.7f, 1.0f), //dxf color code 162

    aiColor4D (0.5f, 0.6f ,0.7f, 1.0f), //dxf color code 163

    aiColor4D (0.0f, 0.1f ,0.5f, 1.0f), //dxf color code 164

    aiColor4D (0.3f, 0.4f ,0.5f, 1.0f), //dxf color code 165

    aiColor4D (0.0f, 0.1f ,0.4f, 1.0f), //dxf color code 166

    aiColor4D (0.3f, 0.3f ,0.4f, 1.0f), //dxf color code 167

    aiColor4D (0.0f, 0.1f ,0.3f, 1.0f), //dxf color code 168

    aiColor4D (0.2f, 0.2f ,0.3f, 1.0f), //dxf color code 169

    aiColor4D (0.0f, 0.0f ,1.0f, 1.0f), //dxf color code 170

    aiColor4D (0.7f, 0.7f ,1.0f, 1.0f), //dxf color code 171

    aiColor4D (0.0f, 0.0f ,0.7f, 1.0f), //dxf color code 172

    aiColor4D (0.5f, 0.5f ,0.7f, 1.0f), //dxf color code 173

    aiColor4D (0.0f, 0.0f ,0.5f, 1.0f), //dxf color code 174

    aiColor4D (0.3f, 0.3f ,0.5f, 1.0f), //dxf color code 175

    aiColor4D (0.0f, 0.0f ,0.4f, 1.0f), //dxf color code 176

    aiColor4D (0.3f, 0.3f ,0.4f, 1.0f), //dxf color code 177

    aiColor4D (0.0f, 0.0f ,0.3f, 1.0f), //dxf color code 178

    aiColor4D (0.2f, 0.2f ,0.3f, 1.0f), //dxf color code 179

    aiColor4D (0.2f, 0.0f ,1.0f, 1.0f), //dxf color code 180

    aiColor4D (0.7f, 0.7f ,1.0f, 1.0f), //dxf color code 181

    aiColor4D (0.2f, 0.0f ,0.7f, 1.0f), //dxf color code 182

    aiColor4D (0.6f, 0.5f ,0.7f, 1.0f), //dxf color code 183

    aiColor4D (0.1f, 0.0f ,0.5f, 1.0f), //dxf color code 184

    aiColor4D (0.4f, 0.3f ,0.5f, 1.0f), //dxf color code 185

    aiColor4D (0.1f, 0.0f ,0.4f, 1.0f), //dxf color code 186

    aiColor4D (0.3f, 0.3f ,0.4f, 1.0f), //dxf color code 187

    aiColor4D (0.1f, 0.0f ,0.3f, 1.0f), //dxf color code 188

    aiColor4D (0.2f, 0.2f ,0.3f, 1.0f), //dxf color code 189

    aiColor4D (0.5f, 0.0f ,1.0f, 1.0f), //dxf color code 190

    aiColor4D (0.8f, 0.7f ,1.0f, 1.0f), //dxf color code 191

    aiColor4D (0.4f, 0.0f ,0.7f, 1.0f), //dxf color code 192

    aiColor4D (0.6f, 0.5f ,0.7f, 1.0f), //dxf color code 193

    aiColor4D (0.3f, 0.0f ,0.5f, 1.0f), //dxf color code 194

    aiColor4D (0.4f, 0.3f ,0.5f, 1.0f), //dxf color code 195

    aiColor4D (0.2f, 0.0f ,0.4f, 1.0f), //dxf color code 196

    aiColor4D (0.3f, 0.3f ,0.4f, 1.0f), //dxf color code 197

    aiColor4D (0.2f, 0.0f ,0.3f, 1.0f), //dxf color code 198

    aiColor4D (0.3f, 0.2f ,0.3f, 1.0f), //dxf color code 199

    aiColor4D (0.7f, 0.0f ,1.0f, 1.0f), //dxf color code 200

    aiColor4D (0.9f, 0.7f ,1.0f, 1.0f), //dxf color code 201

    aiColor4D (0.6f, 0.0f ,0.7f, 1.0f), //dxf color code 202

    aiColor4D (0.7f, 0.5f ,0.7f, 1.0f), //dxf color code 203

    aiColor4D (0.4f, 0.0f ,0.5f, 1.0f), //dxf color code 204

    aiColor4D (0.5f, 0.3f ,0.5f, 1.0f), //dxf color code 205

    aiColor4D (0.3f, 0.0f ,0.4f, 1.0f), //dxf color code 206

    aiColor4D (0.4f, 0.3f ,0.4f, 1.0f), //dxf color code 207

    aiColor4D (0.2f, 0.0f ,0.3f, 1.0f), //dxf color code 208

    aiColor4D (0.3f, 0.2f ,0.3f, 1.0f), //dxf color code 209

    aiColor4D (1.0f, 0.0f ,1.0f, 1.0f), //dxf color code 210

    aiColor4D (1.0f, 0.7f ,1.0f, 1.0f), //dxf color code 211

    aiColor4D (0.7f, 0.0f ,0.7f, 1.0f), //dxf color code 212

    aiColor4D (0.7f, 0.5f ,0.7f, 1.0f), //dxf color code 213

    aiColor4D (0.5f, 0.0f ,0.5f, 1.0f), //dxf color code 214

    aiColor4D (0.5f, 0.3f ,0.5f, 1.0f), //dxf color code 215

    aiColor4D (0.4f, 0.0f ,0.4f, 1.0f), //dxf color code 216

    aiColor4D (0.4f, 0.3f ,0.4f, 1.0f), //dxf color code 217

    aiColor4D (0.3f, 0.0f ,0.3f, 1.0f), //dxf color code 218

    aiColor4D (0.3f, 0.2f ,0.3f, 1.0f), //dxf color code 219

    aiColor4D (1.0f, 0.0f ,0.7f, 1.0f), //dxf color code 220

    aiColor4D (1.0f, 0.7f ,0.9f, 1.0f), //dxf color code 221

    aiColor4D (0.7f, 0.0f ,0.6f, 1.0f), //dxf color code 222

    aiColor4D (0.7f, 0.5f ,0.7f, 1.0f), //dxf color code 223

    aiColor4D (0.5f, 0.0f ,0.4f, 1.0f), //dxf color code 224

    aiColor4D (0.5f, 0.3f ,0.5f, 1.0f), //dxf color code 225

    aiColor4D (0.4f, 0.0f ,0.3f, 1.0f), //dxf color code 226

    aiColor4D (0.4f, 0.3f ,0.4f, 1.0f), //dxf color code 227

    aiColor4D (0.3f, 0.0f ,0.2f, 1.0f), //dxf color code 228

    aiColor4D (0.3f, 0.2f ,0.3f, 1.0f), //dxf color code 229

    aiColor4D (1.0f, 0.0f ,0.5f, 1.0f), //dxf color code 230

    aiColor4D (1.0f, 0.7f ,0.8f, 1.0f), //dxf color code 231

    aiColor4D (0.7f, 0.0f ,0.4f, 1.0f), //dxf color code 232

    aiColor4D (0.7f, 0.5f ,0.6f, 1.0f), //dxf color code 233

    aiColor4D (0.5f, 0.0f ,0.3f, 1.0f), //dxf color code 234

    aiColor4D (0.5f, 0.3f ,0.4f, 1.0f), //dxf color code 235

    aiColor4D (0.4f, 0.0f ,0.2f, 1.0f), //dxf color code 236

    aiColor4D (0.4f, 0.3f ,0.3f, 1.0f), //dxf color code 237

    aiColor4D (0.3f, 0.0f ,0.2f, 1.0f), //dxf color code 238

    aiColor4D (0.3f, 0.2f ,0.3f, 1.0f), //dxf color code 239

    aiColor4D (1.0f, 0.0f ,0.2f, 1.0f), //dxf color code 240

    aiColor4D (1.0f, 0.7f ,0.7f, 1.0f), //dxf color code 241

    aiColor4D (0.7f, 0.0f ,0.2f, 1.0f), //dxf color code 242

    aiColor4D (0.7f, 0.5f ,0.6f, 1.0f), //dxf color code 243

    aiColor4D (0.5f, 0.0f ,0.1f, 1.0f), //dxf color code 244

    aiColor4D (0.5f, 0.3f ,0.4f, 1.0f), //dxf color code 245

    aiColor4D (0.4f, 0.0f ,0.1f, 1.0f), //dxf color code 246

    aiColor4D (0.4f, 0.3f ,0.3f, 1.0f), //dxf color code 247

    aiColor4D (0.3f, 0.0f ,0.1f, 1.0f), //dxf color code 248

    aiColor4D (0.3f, 0.2f ,0.2f, 1.0f), //dxf color code 249

    aiColor4D (0.2f, 0.2f ,0.2f, 1.0f), //dxf color code 250

    aiColor4D (0.3f, 0.3f ,0.3f, 1.0f), //dxf color code 251

    aiColor4D (0.4f, 0.4f ,0.4f, 1.0f), //dxf color code 252

    aiColor4D (0.5f, 0.5f ,0.5f, 1.0f), //dxf color code 253

    aiColor4D (0.7f, 0.7f ,0.7f, 1.0f), //dxf color code 254

    aiColor4D (1.0f, 1.0f ,1.0f, 1.0f) //dxf color code 255

};

#define AI_DXF_NUM_INDEX_COLORS (sizeof(g_aclrDxfIndexColors)/sizeof(g_aclrDxfIndexColors[0]))

#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 constexpr aiImporterDesc desc = {

    "Drawing Interchange Format (DXF) Importer",

    "",

    "",

    "",

    aiImporterFlags_SupportTextFlavour | aiImporterFlags_LimitedSupport,

    0,

    0,

    0,

    0,

    "dxf"

};

// ------------------------------------------------------------------------------------------------

// Returns whether the class can handle the format of the given file.

bool DXFImporter::CanRead( const std::string& filename, IOSystem* pIOHandler, bool /*checkSig*/ ) const {

    static const char *tokens[] = { "SECTION", "HEADER", "ENDSEC", "BLOCKS" };

    return SearchFileHeaderForToken(pIOHandler, filename, tokens, AI_COUNT_OF(tokens), 32);

}

// ------------------------------------------------------------------------------------------------

// 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& filename, aiScene* pScene, IOSystem* pIOHandler) {

    std::shared_ptr<IOStream> file = std::shared_ptr<IOStream>( pIOHandler->Open( filename) );

    // Check whether we can read the file

    if (file == nullptr) {

        throw DeadlyImportError( "Failed to open DXF file ", filename, "");

    }

    // Check whether this is a binary DXF file - we can't read binary DXF files :-(

    char buff[AI_DXF_BINARY_IDENT_LEN] = {0};

    file->Read(buff,AI_DXF_BINARY_IDENT_LEN,1);

    if (0 == memcmp(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( std::move(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)) {

            ASSIMP_LOG_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) {

        ASSIMP_LOG_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

    // poly-count 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());

            }

        }

        ASSIMP_LOG_VERBOSE_DEBUG("DXF: Unexpanded polycount is ", icount, ", vertex count is ", vcount);

    }

    if (output.blocks.empty()) {

        throw DeadlyImportError("DXF: no data blocks loaded");

    }

    DXF::Block* entities( nullptr );

    // 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 ( 0 == 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()) {

            ASSIMP_LOG_ERROR("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;

        const size_t size = bl_src.lines.size(); // the size may increase in the loop

        for (size_t i = 0; i < size; ++i) {

            std::shared_ptr<const DXF::PolyLine> pl_in = bl_src.lines[i];

            if (!pl_in) {

                ASSIMP_LOG_ERROR("DXF: PolyLine instance is nullptr, skipping.");

                continue;

            }

            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);

                //Need to translate position before scaling the insert

                //otherwise the position ends up being the position*scaling

                //STH 2024.01.17

                trafo *= aiMatrix4x4::Translation(insert.pos,tmp);

                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) {

                    ASSIMP_LOG_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& ) {

    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;

    }

    ASSIMP_LOG_VERBOSE_DEBUG("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.emplace_back();

    DXF::Block& block = output.blocks.back();

    while( !reader.End() && !reader.Is(0,"ENDBLK")) {

        switch(reader.GroupCode()) {

            case GroupCode_Name:

                block.name = reader.Value();

                break;

            case GroupCode_XComp:

                block.base.x = reader.ValueAsFloat();

                break;

            case GroupCode_YComp:

                block.base.y = reader.ValueAsFloat();

                break;

            case GroupCode_ZComp:

                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")) {

            ASSIMP_LOG_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.emplace_back();

    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;

    }

    ASSIMP_LOG_VERBOSE_DEBUG( "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.emplace_back();

    DXF::InsertBlock& bl = output.blocks.back().insertions.back();

    while( !reader.End() && !reader.Is(0)) {

        switch(reader.GroupCode()) {

            // name of referenced block

        case GroupCode_Name:

            bl.name = reader.Value();

            break;

            // translation

        case GroupCode_XComp:

            bl.pos.x = reader.ValueAsFloat();

            break;

        case GroupCode_YComp:

            bl.pos.y = reader.ValueAsFloat();

            break;

        case GroupCode_ZComp:

            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++;

    }

}

static constexpr unsigned int DXF_POLYLINE_FLAG_CLOSED = 0x1;

// Currently unused

//static constexpr unsigned int DXF_POLYLINE_FLAG_3D_POLYLINE = 0x8;

//static constexpr unsigned int DXF_POLYLINE_FLAG_3D_POLYMESH = 0x10;

static constexpr unsigned int 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 (vguess && line.positions.size() != vguess) {

        ASSIMP_LOG_WARN("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)   {

            ASSIMP_LOG_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) {

            ASSIMP_LOG_WARN( "DXF: unexpected face count in polymesh: ", line.counts.size(),", expected ", iguess );

        }

    }

    else if (!line.indices.size() && !line.counts.size()) {

        // a poly-line - 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 poly-line

                // entity resides on as well.

                if(reader.Value() != line.layer) {

                    ASSIMP_LOG_WARN("DXF: expected vertex to be part of a poly-face but the 0x128 flag isn't set");

                }

                break;

        case 70:

                flags = reader.ValueAsUnsignedInt();

                break;

        // VERTEX COORDINATES

        case GroupCode_XComp:

            out.x = reader.ValueAsFloat();

            break;

        case GroupCode_YComp:

            out.y = reader.ValueAsFloat();

            break;

        case GroupCode_ZComp:

            out.z = reader.ValueAsFloat();

            break;

        // POLYFACE vertex indices

        case 71:

        case 72:

        case 73:

        case 74: {

                if (cnti == 4) {

                    ASSIMP_LOG_WARN("DXF: more than 4 indices per face not supported; ignoring");

                    break;

                }

                const int index = reader.ValueAsSignedInt();

                if (index >= 0) {

                    indices[cnti++] = static_cast<unsigned int>(index);

                } else {

                    indices[cnti++] = static_cast<unsigned int>(-index);

                }

            }

            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)) {

        ASSIMP_LOG_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) {

                ASSIMP_LOG_WARN("DXF: invalid vertex index, indices are one-based.");

                --line.counts.back();

                // Workaround to fix issue 2229

                if (line.counts.back() == 0) {

                    line.counts.pop_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;