void Viewer::cb_Save()
{
std::string filters("all (*.*);; map (*.map);; off (*.off);; ply (*.ply)") ;
std::string filename = selectFileSave("Save Mesh", "", filters) ;
exportMesh(filename) ;
}
bool RigidMeshExporter::exportTo(std::ostream& output,
bool compressePos,
bool compressNormal,
bool compressTexcoord,
bool compressWeight) const
{
//MESH
//ATCH
size_t fileChunkSize;
if (!exportMesh(output, &fileChunkSize, compressePos, compressNormal, compressTexcoord))
{
return false;
}
size_t nameChunkSize;
if (!m_attachedBoneName.empty())
{
if (!writeStringChunk(output, m_attachedBoneName, nameChunkSize, 'ATCH'))
{
return false;
}
fileChunkSize += (nameChunkSize + CHUNK_HEADER_SIZE);
if (!updateChunkSize(output, fileChunkSize))
{
return false;
}
}
return true;
}
MainWindow::MainWindow(tdv::TDVContext *ctx)
{
m_ctx = ctx;
m_reconst = NULL;
m_camsDialog = NULL;
m_rectDialog = NULL;
m_dispDialog = NULL;
setupUi(this);
connect(pbCamerasView, SIGNAL(clicked()),
this, SLOT(showCamerasViews()));
connect(pbReconstFrame, SIGNAL(clicked()),
this, SLOT(stepReconstruction()));
connect(pbReconstStream, SIGNAL(clicked()),
this, SLOT(playReconstruction()));
connect(pbDisparityMap, SIGNAL(clicked()),
this, SLOT(showDisparity()));
connect(pbRectification, SIGNAL(clicked()),
this, SLOT(showRectification()));
pbExport->setEnabled(true);
pbRectification->setEnabled(false);
pbDisparityMap->setEnabled(false);
m_reprView = new ReprojectionView(this);
layReproj->addWidget(m_reprView, 0, 0);
connect(pbExport, SIGNAL(clicked()),
m_reprView, SLOT(exportMesh()));
}
bool exportGeometry(GeometryPtr &geom, TiXmlElement *xml)
{
TiXmlElement *geometry_xml = new TiXmlElement("geometry");
if( geom->type == Geometry::SPHERE )
{
exportSphere(*((Sphere*)toPlainGeometryPtr(geom)), geometry_xml);
}
else if ( geom->type == Geometry::BOX )
{
exportBox(*((Box*)toPlainGeometryPtr(geom)), geometry_xml);
}
else if (geom->type == Geometry::CYLINDER)
{
exportCylinder(*((Cylinder*)toPlainGeometryPtr(geom)), geometry_xml);
}
else if (geom->type == Geometry::MESH)
{
exportMesh(*((Mesh*)toPlainGeometryPtr(geom)), geometry_xml);
}
else
{
logError("geometry not specified, I'll make one up for you!");
Sphere *s = new Sphere();
s->radius = 0.03;
resetPtr(geom,s);
exportSphere(*s, geometry_xml);
}
xml->LinkEndChild(geometry_xml);
return true;
}
bool exportGeometry(GeometrySharedPtr &geom, TiXmlElement *xml)
{
TiXmlElement *geometry_xml = new TiXmlElement("geometry");
if (urdf::dynamic_pointer_cast<Sphere>(geom))
{
exportSphere((*(urdf::dynamic_pointer_cast<Sphere>(geom).get())), geometry_xml);
}
else if (urdf::dynamic_pointer_cast<Box>(geom))
{
exportBox((*(urdf::dynamic_pointer_cast<Box>(geom).get())), geometry_xml);
}
else if (urdf::dynamic_pointer_cast<Cylinder>(geom))
{
exportCylinder((*(urdf::dynamic_pointer_cast<Cylinder>(geom).get())), geometry_xml);
}
else if (urdf::dynamic_pointer_cast<Mesh>(geom))
{
exportMesh((*(urdf::dynamic_pointer_cast<Mesh>(geom).get())), geometry_xml);
}
else
{
CONSOLE_BRIDGE_logError("geometry not specified, I'll make one up for you!");
Sphere *s = new Sphere();
s->radius = 0.03;
geom.reset(s);
exportSphere((*(urdf::dynamic_pointer_cast<Sphere>(geom).get())), geometry_xml);
}
xml->LinkEndChild(geometry_xml);
return true;
}
void StatefulMeshSerializer::saveMesh(const Ogre::String& name, bool keepEndianess)
{
if (mMesh.isNull())
{
throw std::logic_error("No mesh to save set.");
}
Endian endianMode = keepEndianess ? mMeshFileEndian : ENDIAN_NATIVE;
exportMesh(mMesh.getPointer(), name, endianMode);
}
//---------------------------------------------------------------------
void MeshSerializer::exportMesh(const Mesh* pMesh, const String& filename,
Endian endianMode)
{
std::fstream *f = OGRE_NEW_T(std::fstream, MEMCATEGORY_GENERAL)();
f->open(filename.c_str(), std::ios::binary | std::ios::out);
DataStreamPtr stream(OGRE_NEW FileStreamDataStream(f));
exportMesh(pMesh, stream, endianMode);
stream->close();
}
//---------------------------------------------------------------------
void MeshSerializer::exportMesh(const Mesh* pMesh, const String& filename,
MeshVersion version, Endian endianMode)
{
if( version == MESH_VERSION_LEGACY )
{
OGRE_EXCEPT( Exception::ERR_INVALIDPARAMS,
"You may not supply a legacy version number for writing meshes.",
"MeshSerializer::exportMesh" );
}
std::fstream *f = OGRE_NEW_T(std::fstream, MEMCATEGORY_GENERAL)();
f->open(filename.c_str(), std::ios::binary | std::ios::out);
DataStreamPtr stream(OGRE_NEW FileStreamDataStream(f));
exportMesh(pMesh, stream, version, endianMode);
stream->close();
}
//---------------------------------------------------------------------
void MeshSerializer::exportMesh(const Mesh* pMesh, DataStreamPtr stream,
Endian endianMode)
{
exportMesh(pMesh, stream, MESH_VERSION_LATEST, endianMode);
}
int main()
{
rcAllocSetCustom(allocCustom<rcAllocHint>, freeCustom);
dtAllocSetCustom(allocCustom<dtAllocHint>, freeCustom);
BuildContext ctx;
InputGeom geom;
geom.load(&ctx, "./geomset.txt");
ArMeshDataBuilder builder(&ctx, &geom, meshProcess);
builder.setAgentMaxClimb(1.8f);
ArMeshDataPtr data = builder.build();
if (!data)
{
ctx.log(RC_LOG_ERROR, "Build ArMeshData failed.");
return -1;
}
ctx.log(RC_LOG_PROGRESS, "Total build time: %d ms", ctx.getAccumulatedTime(RC_TIMER_TOTAL));
if (!save(&ctx, data))
{
return -1;
}
FILE* in = fopen("./all_tiles_navmesh.bin", "rb");
if (!in)
{
ctx.log(RC_LOG_ERROR, "Open all_tiles_navmesh.bin failed.");
return -1;
}
ArMeshDataFileReader reader(in);
if (!reader.serialize(*data))
{
ctx.log(RC_LOG_ERROR, "Read ArMeshData failed.");
fclose(in);
return -1;
}
fclose(in);
ArMesh mesh;
ArMeshImporter importer(mesh);
if (!importer.serialize(*data))
{
ctx.log(RC_LOG_ERROR, "Import ArMeshData failed.");
return -1;
}
ArQuery query;
if (dtStatusFailed(query.init(&mesh, 2048)))
{
ctx.log(RC_LOG_ERROR, "Init ArQuery failed.");
return -1;
}
float sp[3];
printf("start: ");
scanf("%f%f%f", sp, sp + 1, sp + 2);
float ep[3];
printf("end: ");
scanf("%f%f%f", ep, ep + 1, ep + 2);
float ext[3] = {2, 4, 2};
dtQueryFilter filter;
filter.setAreaCost(SAMPLE_POLYAREA_GROUND, 1.0f);
filter.setAreaCost(SAMPLE_POLYAREA_WATER, 10.0f);
filter.setAreaCost(SAMPLE_POLYAREA_ROAD, 1.0f);
filter.setAreaCost(SAMPLE_POLYAREA_DOOR, 1.0f);
filter.setAreaCost(SAMPLE_POLYAREA_GRASS, 2.0f);
filter.setAreaCost(SAMPLE_POLYAREA_JUMP, 1.5f);
dtPolyRef sr;
query.backend()->findNearestPoly(sp, ext, &filter, &sr, 0);
dtPolyRef er;
query.backend()->findNearestPoly(ep, ext, &filter, &er, 0);
dtPolyRef polys[256];
int npolys;
query.backend()->findPath(sr, er, sp, ep, &filter, polys, &npolys, 256);
float path[256 * 3];
dtPolyRef pathPolys[256];
unsigned char pathFlags[256];
int pathLen;
query.backend()->findStraightPath(sp, ep, polys, npolys, path, pathFlags, pathPolys, &pathLen, 256, 0);
printf("path:\n%d\n", pathLen);
for (int i = 0; i < pathLen; ++i)
{
printf("%f %f %f\n", path[i * 3], path[i * 3 + 1], path[i * 3 + 2]);
}
if (!exportMesh(&ctx, mesh))
{
return -1;
}
return 0;
}
