How to work with .obj files in CGAL - c++

I am trying to build a simple first person shooter using openGL, SDL and CGAL. I would like to be able to load objects with textures I create in blender into the game and use CGAL to perform computation on the objects/textures (such as subdivision for example) but I can not figure out how to a .obj file into CGAL containers I can work with.
Just using openGL and glut I am able to load .obj files into the game and map the textures to the objects using a vector for each of the coordinates of the obj and its corresponding texture.
Using CGAL I can load the object from a .obj file into a Polyhedron mesh using code I found here: http://jamesgregson.blogspot.ca/2012/05/example-code-for-building.html
What is the best way to work with .obj files in CGAL?


You will need to extend CGAL's vertex class in order to be able to store texture coordinates in it. There is in CGAL a ParameterizationMesh class that does more or less what you need:
http://doc.cgal.org/latest/Surface_mesh_parameterization/classParameterizationMesh__3.html
Then you got two options: (1) use ParameterizationMesh directly if it fits your needs or (2) see how ParameterizationMesh works and extends the vertices of CGAL Polyhedron and do something similar.


I am not familiar with CGAL but I have worked with *.obj files a few times. It would be a tedious task but you would need a few things to achieve your goal.
A file parser to parse your *.obj file for all the elements: vertex data, index data, texture coordinates, material data etc., that you will need in your engine.
A custom user defined struct with an appropriate constructor to contain those elements.
You will then need either stand alone functions or a ManagerClass object that will allow you to use your user defined vector of structs to convert them to a struct object that the CGAL library - API is expecting.
It seems that 1/2 your work is done since you can read in and load the model data from blender into your GameEngine and render the models correctly. You may have to modify your user defined struct, functions or class object to work with CGAL.
A good way to test if your file loader / parser is working correctly is to log your data structures into a text file format for easy reading. This way when you read the text file you can then test if you are getting the correct data.
In order to incorporate this into CGAL to do data processing you will need to know the library - api and which function calls to use, what kind of data they are expecting, and when or which order to call the methods.
This is not a definitive or direct answer to your current problem but should serve as a helpful guideline.

Related

Is there a way to save CGAL::Linear_cell_complex_for_combinatorial_map as .off or .obj format?

I have just implemented an algorithm that takes a surface mesh, tetrahedralizes it and saves the tetrahedralization data inside the CGAL data structure CGAL::Linear_cell_complex_for_combinatorial_map.
I'm new to using CGAL library and I would like to know if there is a way to write CGAL::Linear_cell_complex_for_combinatorial_map data structure in .obj, .off or some other formats.

There is an undocumented function write_off(lcc) (cf here).
In the off, when a face is shared by two volumes, the face is saved twice. Moreover, the output mesh is not a surface, and some tools (like meshlab) does not like such a mesh.
It is easy to modify the code of write_off to save only the surface of your volumic mesh. Contact me if you need such function.

Simple 3D scene visualisation data format

My PhD project revoles around simulating the paths of photons through objects of different optical properties. My code has classes which create ccd images etc, but it would be much more useful to be able to create a simple rendering of the 3D objects and the paths the photons take through them.
I've written an opengl system for viewing such a scene, but it would be much better if I could use something much more lightweight where I could simply specify the vertices of an object, and then a photon path as a list of connected vertices.
Exporting all the data and then visualising it in another program isn't ideal, as things like mesh transformations need to be taken into account, and I'd rather avoid exporting several new mesh objects just to import them all into another program.
What I essentially need is to be able to create the three dimensional equivalent of a svg image. Does such a '3D scene' file format with a simple visualiser exist?
I write in C++ on MacOS, though I'd prefer to avoid using a visualisation library. I appreciate that what I'm asking for is rather niece and picky, but that's why I'm asking the internet as someone might have come across a similar need for such a tool.

Joining two meshes into one

Suppose I have two meshes stored in any sane format (e.g. wavefront .obj or collada .dae), and I want to combine them into one mesh programmatically. More precise, I have a landscape and an object as two meshes. I want to put object into landscape after performing transformation to it, so it gets on the right place, and export this as result model.
As far as I understood, in assimp there is something similar named SceneCombiner, yet it seems that this is internal structure and has no interface (even though here https://github.com/assimp/assimp/issues/584 the ticket concerning it is closed, I couldn't find out how to use it).
Maybe I should use CGAL or something like that? I don't have very much experience in CG libraries, so any advice will be really useful!

You can do that with CGAL. You would read two meshes, and the call copy_face_graph(), and then write the mesh back.

Using tetrahedron to model deformable objects in OpenGL

I want to render a mesh made up of tetrahedron in OpenGL because I am trying to implement animation which requires the use of the 'finite element method'. As a novice of OpenGL, I am not quite sure how to approach this.
So far, I have come across NETGEN which is supposed to generate a tetrahedral mesh from an object. From the example I downloaded, it takes a .geo file for input and outputs a .vol file.
The .vol file has a lot of data points and variables listed inside. Is this a standard file to read in? Or is it proprietary depending on which software generates it? In other words, are there standard methods for rendering this kind of file or do I need to manually parse the data from the file and then somehow render it as GL_LINES, etc?

it takes a .geo file for input and outputs a .vol file
The name suffixes are absolutely nontelling.
Anyway, OpenGL deals with providing drawing tools only. There's no functionality to read in files, be it geometry or images. And thus there is no "standard OpenGL file format".
Indeed it's your deed to read in those files, either with a parser you write, or some third party library, and pass the data to OpenGL, then issuing the right commands to make OpenGL draw a picture from the data.

Using Blender/SketchUp Models in OpenGL

I'm making a renderer using OpenGL. I have textured models in Blender / Sketchup (I can exchange between the two easily), and I'd like to be able to export those files into my renderer. My initial idea was to simply export the raw faces and render those triangles, but I'd like to easily slice my texture files into texture coordinates as well.
By that, I mean that my model faces get carved into triangles. You can see in this image (reproduced below) that my curve becomes 24 triangles. I would like to know what texture coordinates to use for each triangle.
Would a DAE file be the easiest way to do that? I've been reading the specs for the format and it looks easy enough. I think I could parse the XML and faithfully recreate the models in OpenGL. I'm wondering if there is an easier way (i.e. one that doesn't reinvent the wheel).

If you're comfortable with parsing the .dae-format, sure use it. However, if you're only interested in exporting textured triangle meshes I would consider using the .obj format which is much more simple to parse. From what I can tell both Sketchup and Blender can export this format.

If binary formats don't scare you, I'd suggest writing a Blender & Sketchup plug-in and exporting the geometry pre-baked into packed vertex arrays.
The beautiful thing about this method is that there's no parsing or type conversion in your app. Everything is ready to be sent to the GPU in simple contiguous memory copies. Great for static geometry.
A stripped down blender exporter looks something like this:
#!BPY
import bpy, struct
from Blender import *
self.fh = open("MyFileName", "w")
m = bpy.data.meshes["MyMeshName"]
faces = m.faces
for face in faces:
for (vertex, uv) in zip(face.verts, face.uv):
self.fh.write(struct.pack('<fff', *vertex.co)) # coords
self.fh.write(struct.pack('<fff', *vertex.no)) # normals
self.fh.write(struct.pack('<ff', uv.x, uv.y)) # uvs
self.fh.close()

If you wish to parse .dae files, i would suggest to look into Collada parsers.
.dae is actually the extension for Collada files, the latest effort from the Khronos group (maintainers of OpenGL) to have a single unified file format for 3D data exchange.
As for the existing parsers, here is what I've come across:
collada-dom, the reference implementation. As the name suggests, it is just an abstraction of the XML tree.
FCollada, a nicer abstraction. However, this project has been dead for almost two years, and, from what I've gathered, it is unlikely that we'll see any update in the future.
OpenCollada, a recent new effort. Haven't tried it, but there is an active community behind it.
That being said, if your only goal is loading a simple piece of geometry with vertices, normals and texture coordinates, going with the .obj file format might be a quicker way.

Any decent file format used by modeling programs (such as Blender or Sketchup) will include all information necessary to recreate the geometry you see. This should include the geometry type (e.g. triangle strips, individual triangles, etc), the vertices and normals for the geometry, the material properties used, and also the textures used along with the appropriate texture coordinates. If anything is lacking from a potential file format, choose another one.
If you think that parsing XML is simple, then I hope you're planning on using existing libraries to do this, such as expat, Xerces, or some other language specific implementation.
When considering import/export, first try to find an open source library that can handle the import for you and make the data available to your program in a reasonable format. If that's not available, and you must write your own importer, then try to find a simple ASCII (not XML-based) or binary format that fits your needs. PLY might be suitable. Only as a a last resort, would I recommend trying to implement an importer for an XML-based format.

There's also:
Lib3DS - http://www.lib3ds.org/
LibOBJ (won't let me post link)

You should take a look at:
http://sketchup.google.com/community/developers.html
The sketchup team provides a C++ COM server for free. Using this, you can get access to lots of information about a .skp file.
You should be able to use this COM server to write a .skp importer for your application.
You should try to get the .tlb file if you can. This will give you access to smart pointers, which will simplify your importer (COM client)
I used the version 6 SDK (which included the tlb file). The current version of the SDK does not appear to include this file.
Someone posted a solution (for the missing tlb file) on the developer forums:
http://groups.google.com/group/su-sdk-fileshare/topics