git.sur5r.net Git - fstl/blob - src/loader.cpp

   1 #include <future>
   2
   3 #include "loader.h"
   4 #include "vertex.h"
   5
   6 Loader::Loader(QObject* parent, const QString& filename, bool is_reload)
   7     : QThread(parent), filename(filename), is_reload(is_reload)
   8 {
   9     // Nothing to do here
  10 }
  11
  12 void Loader::run()
  13 {
  14     Mesh* mesh = load_stl();
  15     if (mesh)
  16     {
  17         if (mesh->empty())
  18         {
  19             emit error_empty_mesh();
  20             delete mesh;
  21         }
  22         else
  23         {
  24             emit got_mesh(mesh, is_reload);
  25             emit loaded_file(filename);
  26         }
  27     }
  28 }
  29
  30 ////////////////////////////////////////////////////////////////////////////////
  31
  32 void parallel_sort(Vertex* begin, Vertex* end, int threads)
  33 {
  34     if (threads < 2 || end - begin < 2)
  35     {
  36         std::sort(begin, end);
  37     }
  38     else
  39     {
  40         const auto mid = begin + (end - begin) / 2;
  41         if (threads == 2)
  42         {
  43             auto future = std::async(parallel_sort, begin, mid, threads / 2);
  44             std::sort(mid, end);
  45             future.wait();
  46         }
  47         else
  48         {
  49             auto a = std::async(std::launch::async, parallel_sort, begin, mid, threads / 2);
  50             auto b = std::async(std::launch::async, parallel_sort, mid, end, threads / 2);
  51             a.wait();
  52             b.wait();
  53         }
  54         std::inplace_merge(begin, mid, end);
  55     }
  56 }
  57
  58 Mesh* mesh_from_verts(uint32_t tri_count, QVector<Vertex>& verts)
  59 {
  60     // Save indicies as the second element in the array
  61     // (so that we can reconstruct triangle order after sorting)
  62     for (size_t i=0; i < tri_count*3; ++i)
  63     {
  64         verts[i].i = i;
  65     }
  66
  67     // Check how many threads the hardware can safely support. This may return
  68     // 0 if the property can't be read so we shoud check for that too.
  69     auto threads = std::thread::hardware_concurrency();
  70     if (threads == 0)
  71     {
  72         threads = 8;
  73     }
  74
  75     // Sort the set of vertices (to deduplicate)
  76     parallel_sort(verts.begin(), verts.end(), threads);
  77
  78     // This vector will store triangles as sets of 3 indices
  79     std::vector<GLuint> indices(tri_count*3);
  80
  81     // Go through the sorted vertex list, deduplicating and creating
  82     // an indexed geometry representation for the triangles.
  83     // Unique vertices are moved so that they occupy the first vertex_count
  84     // positions in the verts array.
  85     size_t vertex_count = 0;
  86     for (auto v : verts)
  87     {
  88         if (!vertex_count || v != verts[vertex_count-1])
  89         {
  90             verts[vertex_count++] = v;
  91         }
  92         indices[v.i] = vertex_count - 1;
  93     }
  94     verts.resize(vertex_count);
  95
  96     std::vector<GLfloat> flat_verts;
  97     flat_verts.reserve(vertex_count*3);
  98     for (auto v : verts)
  99     {
 100         flat_verts.push_back(v.x);
 101         flat_verts.push_back(v.y);
 102         flat_verts.push_back(v.z);
 103     }
 104
 105     return new Mesh(std::move(flat_verts), std::move(indices));
 106 }
 107
 108 ////////////////////////////////////////////////////////////////////////////////
 109
 110 Mesh* Loader::load_stl()
 111 {
 112     QFile file(filename);
 113     if (!file.open(QIODevice::ReadOnly))
 114     {
 115         emit error_missing_file();
 116         return NULL;
 117     }
 118
 119     // First, try to read the stl as an ASCII file
 120     if (file.read(5) == "solid")
 121     {
 122         file.readLine(); // skip solid name
 123         const auto line = file.readLine().trimmed();
 124         if (line.startsWith("facet") ||
 125             line.startsWith("endsolid"))
 126         {
 127             file.seek(0);
 128             return read_stl_ascii(file);
 129         }
 130         confusing_stl = true;
 131     }
 132     else
 133     {
 134         confusing_stl = false;
 135     }
 136
 137     // Otherwise, skip the rest of the header material and read as binary
 138     file.seek(0);
 139     return read_stl_binary(file);
 140 }
 141
 142 Mesh* Loader::read_stl_binary(QFile& file)
 143 {
 144     QDataStream data(&file);
 145     data.setByteOrder(QDataStream::LittleEndian);
 146     data.setFloatingPointPrecision(QDataStream::SinglePrecision);
 147
 148     // Load the triangle count from the .stl file
 149     file.seek(80);
 150     uint32_t tri_count;
 151     data >> tri_count;
 152
 153     // Verify that the file is the right size
 154     if (file.size() != 84 + tri_count*50)
 155     {
 156         emit error_bad_stl();
 157         return NULL;
 158     }
 159
 160     // Extract vertices into an array of xyz, unsigned pairs
 161     QVector<Vertex> verts(tri_count*3);
 162
 163     // Dummy array, because readRawData is faster than skipRawData
 164     std::unique_ptr<uint8_t> buffer(new uint8_t[tri_count * 50]);
 165     data.readRawData((char*)buffer.get(), tri_count * 50);
 166
 167     // Store vertices in the array, processing one triangle at a time.
 168     auto b = buffer.get() + 3 * sizeof(float);
 169     for (auto v=verts.begin(); v != verts.end(); v += 3)
 170     {
 171         // Load vertex data from .stl file into vertices
 172         for (unsigned i=0; i < 3; ++i)
 173         {
 174             memcpy(&v[i], b, 3*sizeof(float));
 175             b += 3 * sizeof(float);
 176         }
 177
 178         // Skip face attribute and next face's normal vector
 179         b += 3 * sizeof(float) + sizeof(uint16_t);
 180     }
 181
 182     if (confusing_stl)
 183     {
 184         emit warning_confusing_stl();
 185     }
 186
 187     return mesh_from_verts(tri_count, verts);
 188 }
 189
 190 Mesh* Loader::read_stl_ascii(QFile& file)
 191 {
 192     file.readLine();
 193     uint32_t tri_count = 0;
 194     QVector<Vertex> verts(tri_count*3);
 195
 196     bool okay = true;
 197     while (!file.atEnd() && okay)
 198     {
 199         const auto line = file.readLine().simplified();
 200         if (line.startsWith("endsolid"))
 201         {
 202             break;
 203         }
 204         else if (!line.startsWith("facet normal") ||
 205                  !file.readLine().simplified().startsWith("outer loop"))
 206         {
 207             okay = false;
 208             break;
 209         }
 210
 211         for (int i=0; i < 3; ++i)
 212         {
 213             auto line = file.readLine().simplified().split(' ');
 214             if (line[0] != "vertex")
 215             {
 216                 okay = false;
 217                 break;
 218             }
 219             const float x = line[1].toFloat(&okay);
 220             const float y = line[2].toFloat(&okay);
 221             const float z = line[3].toFloat(&okay);
 222             verts.push_back(Vertex(x, y, z));
 223         }
 224         if (!file.readLine().trimmed().startsWith("endloop") ||
 225             !file.readLine().trimmed().startsWith("endfacet"))
 226         {
 227             okay = false;
 228             break;
 229         }
 230         tri_count++;
 231     }
 232
 233     if (okay)
 234     {
 235         return mesh_from_verts(tri_count, verts);
 236     }
 237     else
 238     {
 239         emit error_bad_stl();
 240         return NULL;
 241     }
 242 }
 243