Mesh Intersection

[GeniusProgger]

Hi,

Is it possible to calculate the intersection points (lines) between two meshes? To obtain a line-of-intersection.

I looked at MeshSurfaceIntersection. It only has one input, so I (ugly) combined the input meshes into one mesh. Also the object returned by set_build_skeleton() is not what I need. It returns the triangle edges near the intersection-line, not the intersection-line itself.

Thank you for your help, the lib is awesome.

[BrunoLevy]

Normally the skeleton should be the intersection line itself, would you share your input mesh and code snippet ? I'll take a look.

You can find an example in the Graphite modeler, here

Here is an image of an example (computing the intersection between two brains)

[GeniusProgger]

Example.zip

Interesting, the geogram code looks similar to the Graphite modeler. Are the brains booleaned/union together? Because I just placed two separate object surfaces into a single object. Hence the question about an intersection function with two input meshes.

I have attached an example. I cannot show/give you complete code, because those parts are specific to our application. Thanks!

[BrunoLevy]

The brains are not booleaned/unioned or whatever, I'm just calling the code referenced.
Here is what I obtain with your data

In your code:

GEO::Mesh mesh;
merged->getGeomMesh(mesh); // merged is the loaded STL input file, this function restructures the data to a geogram mesh

GEO::MeshSurfaceIntersection I(mesh);

I.set_verbose(true);
I.set_delaunay(true);
I.set_detect_intersecting_neighbors(true); // set this one (you may have neighboring triangles with intersection in the input)
I.set_normalize(false);
// I.set_radial_sort(true); // not necessary here (but it will not harm)
// I.set_monster_threshold(100); // you do not need this one (dumps triangles with more than 100 intersections in files)
// I.set_dry_run(true); // do not set this one ! if enabled, it does not compute the intersection (this is the problem I think)

GEO::Mesh skel;
I.set_build_skeleton(&skel);

I.intersect();

[GeniusProgger]

That looks good. I tried several combinations...

I interpreted the dry_run as, it wil do/calculate everything, except apply it to the model. Indeed, I get the same result as you now. Thank you.

[BrunoLevy]

Yes, "dry run" is what you mean, but for the skeleton to be computed, the triangles need to be re-triangulated, so skeleton output is incompatible with "dry run" (I have updated the documentation accordingly and added an assertion check).

So if you need to leave your input mesh unmodified, you will need to copy it to another mesh (use Mesh::copy()) and pass the copy to the MeshSurfaceIntersection.

[GeniusProgger]

The skeleton return values with dry_run(true) might still be useful to some. As it returns all vertices involved in the intersection. A documentation update might be enough (perhaps not an assert?).

Yeah, well I just didn't copy the result back to my input (because I have to convert the shape anyways). But when I do, I get face/normal issues. Not yet sure if this problem is on our end though. Maybe face ordering / indexing? For me, it does not matter, since I'm not using that output.

[BrunoLevy]

That's weird !
How did you copy the mesh ?
Here is the way to do that:

GEO::Mesh mesh;
merged->getGeomMesh(mesh); // merged is the loaded STL input file, this function restructures the data to a geogram mesh ...
GEO::Mesh copy;
copy.copy(&mesh);
GEO::MeshSurfaceIntersection I(copy);
// and then as you did

About using the skeleton to return the intersected triangles, I'd rather not expose this functionality, because

• this is not the intended behavior, and if I change the internal algorithm, I do not want to be constrained to preserve this behavior
• there is another (cheaper / more efficient) way of doing that using MeshFacetsAABB as in the following link (in Graphite sources). Result on your data is as follows:

[GeniusProgger]

I understand, side effect behavior is probably undesired :). I see, and that function is (of course) the first step in intersect(). I also looked at intersect_get_intersections() (sound like get the points of intersection, like the skeleton, but a bit more complex because of the IsectInfo structure), but that one is a protected function.

Sorry, I wasn't clear. I meant when I copy the data to/from geogram meshes to/from our own datastructures. It should just copy over vertices and faces and normals (they don't exist in geogram?) in order right?

Example to create a geogram mesh from our Med_SurfaceKit:

void Med_SurfaceKit::getGeoMesh(GEO::Mesh& geomesh) {
	int vc = vertexCount();
	int fc = faceCount();

	const SbVec3f* c = getCoordinates()->getValues(0);
	const int32_t* f = getFaces()->getValues(0);

	for (size_t i = 0; i < vc; i++) {
		GEO::index_t vi = geomesh.vertices.create_vertex();
		geomesh.vertices.point(vi) = GEO::vec3(c[i][0], c[i][1], c[i][2]);
	}

	for (size_t i = 0; i < fc * 3; i += 3) {
		GEO::index_t fi = geomesh.facets.create_polygon(3);
		for (GEO::index_t j = 0; j < 3; ++j) {
			geomesh.facets.set_vertex(fi, j, f[i + j]);
		}
	}
}

And to go from a geogram mesh (e.g. the result of MeshSurfaceIntersection) to our Med_SurfaceKit:

void Med_SurfaceKit::updateShape(GEO::Mesh& geomesh) {
	int newVc = geomesh.vertices.nb();
	int newFc = geomesh.facets.nb();

	// Extract the vertices
	getCoordinates()->setNum(newVc);
	SbVec3f* c = getCoordinates()->startEditing();
	for (GEO::index_t vi = 0; vi < newVc; ++vi) {
		const GEO::vec3& point = geomesh.vertices.point(vi);
		c[vi] = SbVec3f(point[0], point[1], point[2]);
	}

	// Extract the faces
	getFaces()->setNum(newFc * 3);
	int32_t* f = getFaces()->startEditing();

	int fcounter = 0;
	for (GEO::index_t fi = 0; fi < newFc; ++fi) {
		GEO::index_t nb_vertices = geomesh.facets.nb_vertices(fi);
		for (GEO::index_t lv = 0; lv < nb_vertices; ++lv) {
			f[fcounter++] = geomesh.facets.vertex(fi, lv);
		}
	}

	getCoordinates()->finishEditing();
	getFaces()->finishEditing();

	invalidateCache();
}

[BrunoLevy]

This looks correct to me (provided that the facet orientation is correct).

Note: since you already know the number of facets and vertices to create, you may use create_vertices() and create_triangles() instead of creating them one by one, may be faster (it will avoid reallocations).

About the normals, if they are stored in your representation, maybe you need to recompute them ? (then it would explain what we see, that comes from the random values stored in your mesh).