void LVRMainWindow::exportSelectedModel()
{
// Get selected point cloud
QList<QTreeWidgetItem*> items = treeWidget->selectedItems();
if(items.size() > 0)
{
QTreeWidgetItem* item = items.first();
if(item->type() == LVRPointCloudItemType)
{
if(item->parent() && item->parent()->type() == LVRModelItemType)
{
QString qFileName = QFileDialog::getSaveFileName(this, tr("Export Point Cloud As..."), "", tr("Point cloud Files(*.ply *.3d)"));
LVRModelItem* model_item = static_cast<LVRModelItem*>(item->parent());
LVRPointCloudItem* pc_item = static_cast<LVRPointCloudItem*>(item);
PointBufferPtr points = pc_item->getPointBuffer();
// Get transformation matrix
Pose p = model_item->getPose();
Matrix4f mat(Vertexf(p.x, p.y, p.z), Vertexf(p.r, p.t, p.p));
// Allocate target buffer and insert transformed points
size_t n;
floatArr transformedPoints(new float[3 * points->getNumPoints()]);
floatArr pointArray = points->getPointArray(n);
for(size_t i = 0; i < points->getNumPoints(); i++)
{
Vertexf v(pointArray[3 * i], pointArray[3 * i + 1], pointArray[3 * i + 2]);
Vertexf vt = mat * v;
transformedPoints[3 * i ] = vt[0];
transformedPoints[3 * i + 1] = vt[1];
transformedPoints[3 * i + 2] = vt[2];
}
// Save transformed points
PointBufferPtr trans(new PointBuffer);
trans->setPointArray(transformedPoints, n);
ModelPtr model(new Model(trans));
ModelFactory::saveModel(model, qFileName.toStdString());
}
}
}
}
void InteractivePointCloud::updateBuffer(PointBufferPtr buffer)
{
if(buffer)
{
if(!m_boundingBox)
{
m_boundingBox = new BoundingBox<Vertex<float> >;
m_boundingBox->expand(8000, 8000, 8000);
}
size_t num_vertices;
float* vertices = buffer->getPointArray(num_vertices).get();
// m_boundingBox = new BoundingBox<Vertex<float> >;
// for (int i = 0; i < int(num_vertices); i++)
// {
// int index = 3 * i;
// m_boundingBox->expand(vertices[index], vertices[index + 1], vertices[index + 2]);
// }
glVertexPointer(3, GL_FLOAT, 0, vertices);
m_buffer = buffer;
}
}
void DatIO::save(string filename)
{
PointBufferPtr pointBuffer = m_model->m_pointCloud;
float buffer[4];
if(pointBuffer)
{
ofstream out(filename.c_str(), std::ios::binary);
if(out.good())
{
size_t numPoints;
size_t numIntensities;
floatArr pointArray = pointBuffer->getPointArray(numPoints);
floatArr intensityArray = pointBuffer->getPointIntensityArray(numIntensities);
float buffer[4];
cout << timestamp << "Writing " << numPoints << " to " << filename << endl;
for(size_t i = 0; i < numPoints; i++)
{
memset(buffer, 0, 4 * sizeof(float));
size_t pos = i * 3;
buffer[0] = pointArray[pos];
buffer[1] = pointArray[pos + 1];
buffer[2] = pointArray[pos + 2];
if(intensityArray)
{
buffer[3] = intensityArray[i];
}
out.write((char*)buffer, 4 * sizeof(float));
}
out.close();
}
else
{
cout << timestamp << "DatIO: Unable to open file " << filename << " for writing." << endl;
}
}
}
ModelPtr ModelFactory::readModel( std::string filename )
{
ModelPtr m;
// Check extension
boost::filesystem::path selectedFile( filename );
std::string extension = selectedFile.extension().string();
// Try to parse given file
BaseIO* io = 0;
if(extension == ".ply")
{
io = new PLYIO;
}
else if(extension == ".pts" || extension == ".3d" || extension == ".xyz")
{
io = new AsciiIO;
}
else if (extension == ".obj")
{
io = new ObjIO;
}
else if (extension == ".las")
{
io = new LasIO;
}
else if (extension ==".dat")
{
io = new DatIO;
}
#ifdef LVR_USE_PCL
else if (extension == ".pcd")
{
io = new PCDIO;
}
#endif /* LVR_USE_PCL */
else if (extension == "")
{
bool found_3d = false;
bool found_boctree = false;
// Check for supported data in directory.
boost::filesystem::directory_iterator lastFile;
for(boost::filesystem::directory_iterator it(filename); it != lastFile; it++ )
{
boost::filesystem::path p = it->path();
// Check for 3d files
if(p.extension().string() == ".3d")
{
// Check for naming convention "scanxxx.3d"
int num = 0;
if(sscanf(p.filename().string().c_str(), "scan%3d", &num))
{
found_3d = true;
}
}
// Check for .oct files
if(p.extension().string() == ".oct")
{
// Check for naming convention "scanxxx.3d"
int num = 0;
if(sscanf(p.filename().string().c_str(), "scan%3d", &num))
{
found_boctree = true;
}
}
}
// Check and create io
if(!found_boctree && found_3d)
{
io = new UosIO;
}
else if(found_boctree && found_3d)
{
cout << timestamp << "Found 3d files and octrees. Loading octrees per default." << endl;
io = new BoctreeIO;
}
else if(found_boctree && !found_3d)
{
io = new BoctreeIO;
}
else
{
cout << timestamp << "Given directory does not contain " << endl;
}
}
// Return data model
if( io )
{
m = io->read( filename );
if(m_transform.convert)
{
// Convert coordinates in model
PointBufferPtr points = m->m_pointCloud;
size_t n_points = 0;
size_t n_normals = 0;
floatArr p = points->getPointArray(n_points);
floatArr n = points->getPointNormalArray(n_normals);
// If normals are present every point should habe one
if(n_normals)
{
assert(n_normals == n_points);
}
// Convert coordinates
float point[3];
float normal[3];
for(size_t i = 0; i < n_points; i++)
{
// Re-order and scale point coordinates
point[0] = p[3 * i + m_transform.x] * m_transform.sx;
point[1] = p[3 * i + m_transform.y] * m_transform.sy;
point[2] = p[3 * i + m_transform.z] * m_transform.sz;
p[3 * i] = point[0];
p[3 * i + 1] = point[1];
p[3 * i + 2] = point[2];
if(n_normals)
{
normal[0] = n[3 * i + m_transform.x] * m_transform.sx;
normal[1] = n[3 * i + m_transform.y] * m_transform.sy;
normal[2] = n[3 * i + m_transform.z] * m_transform.sz;
n[3 * i] = normal[0];
n[3 * i + 1] = normal[1];
n[3 * i + 2] = normal[2];
}
}
}
delete io;
}
return m;
}
