Reading wavefront OBJ and defining textures

[sergei9838]

Hello, vedo users and Marco!
I have some questions on how import obj-file (especially textured) to a vedo.Mesh. I will illustrate the questions on a cube with coloured faces defined in 3 files:
coloured_cube.obj # defined in the comment - .obj cannot be attached
coloured_cube.mtl - materials definition # defined in the comment - .mtl cannot be attached
cube_face_colours.jpg - the texture

To recall, .obj is a text-file. The lines starting with "v" describe the coordinates of the vertices (8 for the cube), lines starting with "vt" define the uv-coordinates of the vertices mapped onto the jpg-texture as the proportions of its width and height (corner points on the picture above), "vn" - normals, "f" lines are faces in the format vid/tid/nid, where vid is the index of the vertex in the face, tid - the index of the uv-coordinate this vertex maps to, nid - the index of the normal. Thus the first face is [1,5,7,3] (so cell [0,4,6,2] - the numeration starts with 1 in obj-file), etc.

It is possible to load the mesh, ignoring the texture, with

C0 = Mesh("coloured_cube.obj")
print(C0.nvertices)

And here comes the first surprise: it contains 24 vertices instead of 8! Examining
print(C0.cells)
each face generated its own vertex so in the end each vertex was replicated thrice.

Collapsing these with clean makes 8 vertices (as expected) but their indices are changed as seen from the cells:

C0 = Mesh("coloured_cube.obj").clean()
print(C0.nvertices)
print(C0.cells)

That makes texturing with uv-coordinates in the obj-file impossible.
So the first question:

1. Is it possible to make Mesh read an obj-file without creating duplicates and preserving the vertex order?

It is important because I want to import a mesh from 3D software, move some vertices, possibly, re-texture and load it back. But if the vertices get duplicated, I need to detect and move all duplicates. Moreover, 3D soft gets confused when the vertex order has changed.

I have found a nice script wavefront.py that parses obj-file and extracts vertex and faces information (not groups or curves, etc., but for me this is not needed). I renamed load_obj there to load_wavefront_obj so that it does not collide with vedo's function load_obj, see below. Then

from wavefront import load_wavefront_obj
C_obj = load_wavefront_obj("coloured_cube.obj")
verts = C_obj.vertices
uvs = C_obj.texcoords

cells_v = []  # cells
cells_vt = []  # texture vertices ids
cells_vn = []  # normals
for p in C_obj.polygons:
    cells_v.append([i[0] for i in p])
    cells_vt.append([i[1] for i in p])
    cells_vn.append([i[2] for i in p])

I am copying the outcome (compare with what obj-file contains: subtract 1 from indices there):

verts = [[1.0, 1.0, -1.0], [1.0, -1.0, -1.0], [1.0, 1.0, 1.0], [1.0, -1.0, 1.0], [-1.0, 1.0, -1.0], [-1.0, -1.0, -1.0], [-1.0, 1.0, 1.0], [-1.0, -1.0, 1.0]]
cells_v = [[0, 4, 6, 2], [3, 2, 6, 7], [7, 6, 4, 5], [5, 1, 3, 7], [1, 0, 2, 3], [5, 4, 0, 1]]
cells_vt = [[0, 1, 2, 3], [4, 3, 5, 6], [7, 8, 9, 10], [11, 12, 4, 13], [12, 0, 3, 4], [10, 9, 0, 12]]
uvs = [[0.625, 0.5], [0.875, 0.5], [0.875, 0.75], [0.625, 0.75], [0.375, 0.75], [0.625, 1.0], [0.375, 1.0], [0.375, 0.0], [0.625, 0.0], [0.625, 0.25], [0.375, 0.25], [0.125, 0.5], [0.375, 0.5], [0.125, 0.75]]

so now I can define the cube preserving the order of vertices and faces:
C = Mesh([verts, cells_v])
The first cell [0,4,6,2] has texture indices [0,1,2,3] meaning that it is mapped to the rectangle with pixel coordinates 1024 * (uvs[0], uvs[1], uvs[2], uvs[3] ) since cube_face_colours.jpg has size 1024x1024 pixels. Question:

2. How can I attach the texture to C having cells_vt and uvs at hand?

I suspect I need to use C.texture but I do not understand how to use its parameters:
C.texture(tname="cube_face_colours.jpg", tcoords=uvs)
produces the following error message:
[vedo.visual] ERROR: nr of texture coords must match nr of points
This is a strange requirement, because the number of vertices (v-lines in obj-file) need not (and usually does not) equal the number of texture vertices (vt-lines). Indeed, the top left corner of the yellow square and the bottom left corner of the cyan square on the jpg are the images of the same vertex.

I see that there is a function load_obj which is not so well documented nor there are examples.

CC = load_obj("coloured_cube.obj", mtl_file="coloured_cube.mtl", texture_path=".")
print(CC[0].nvertices)
print(CC[1].nvertices)

CC is a list of two meshes. CC[0] has no vertices, no idea what is it. CC[1] is the cube, it still has duplicated vertices, but magically it acquired the texture:
show(CC[1]).close()

3. How do I get uv-coordinates from CC[1]?

Thanks for your much appreciated help!

[sergei9838]

Save as coloured_cube.obj file

mtllib coloured_cube.mtl
o Cube
v 1.000000 1.000000 -1.000000
v 1.000000 -1.000000 -1.000000
v 1.000000 1.000000 1.000000
v 1.000000 -1.000000 1.000000
v -1.000000 1.000000 -1.000000
v -1.000000 -1.000000 -1.000000
v -1.000000 1.000000 1.000000
v -1.000000 -1.000000 1.000000
vt 0.625000 0.500000
vt 0.875000 0.500000
vt 0.875000 0.750000
vt 0.625000 0.750000
vt 0.375000 0.750000
vt 0.625000 1.000000
vt 0.375000 1.000000
vt 0.375000 0.000000
vt 0.625000 0.000000
vt 0.625000 0.250000
vt 0.375000 0.250000
vt 0.125000 0.500000
vt 0.375000 0.500000
vt 0.125000 0.750000
vn 0.0000 1.0000 0.0000
vn 0.0000 0.0000 1.0000
vn -1.0000 0.0000 0.0000
vn 0.0000 -1.0000 0.0000
vn 1.0000 0.0000 0.0000
vn 0.0000 0.0000 -1.0000
usemtl Material
f 1/1/1 5/2/1 7/3/1 3/4/1
f 4/5/2 3/4/2 7/6/2 8/7/2
f 8/8/3 7/9/3 5/10/3 6/11/3
f 6/12/4 2/13/4 4/5/4 8/14/4
f 2/13/5 1/1/5 3/4/5 4/5/5
f 6/11/6 5/10/6 1/1/6 2/13/6

[sergei9838]

Save as coloured_cube.mtl file:

newmtl Material
d 1
Kd 1 1 1
map_Kd cube_face_colours.jpg

[sergei9838]

Cleaning duplicated vertices in CC[1] above produces quite a funky cube, but, unfortunately, useless :)
show(CC[1].lw(1).clean()).close()

[marcomusy]

Hi Sergei - sorry for the late reply.
I think the vertices are triplicated to allow the rendering of the point normals of the faces which are 6 in the file one for each faces.
Without triplicating vertices the point normals would be undefined.

from vedo import *

# this might help to visualize the texture correctly
# settings.interpolate_scalars_before_mapping = False

C0 = Mesh("coloured_cube.obj").lw(1)

C0.add_ids()
# C0.clean().flat()

print(C0.nvertices)
print(C0.cells)
print(C0.pointdata["PointID"])
print(C0.pointdata["Material"])

C0.texture("coloured_cube.jpg", tcoords="Material")
show(C0, axes=1)

In the dev version of vedo there is also a recently added function:

from vedo import *
from vedo.file_io import load_obj

C0 = load_obj("coloured_cube.obj")[1]
print(C0)
# C0.clean().flat()
show(C0, axes=1)

which reads the mtl file and also sets the lighting.
I don't quite understand why 2 meshes are returned, the second one seems to be the right one..

---

Also check

vedo/vedo/utils.py

Line 1472 in cb44ad7

def get_uv(p, x, v):

[sergei9838]

Thank you, Marco! No problem with the delay: I have done some experiments and this is what I have discovered. The vertices are multiplied (by vtk?) as soon as there are // in the definition of faces. This means a texture is defined, and instead of tracking correspondence between a vertex and its texture vertices (so the first pairs in the face vertex indices: 1-1, 2-13, but 5-[2, 10], 7-[3,6,9], etc.) it is simpler just to duplicate vertices in the order they appear in the face definition. Now every face has unique vertices and these are mapped (by vid/tid in the faces' definition) to texture vertices with the uv-coords in vt-lines. And this is how, I bet, Mesh.texture() method works:
I flatten the original (8-vertex cube) list of 24 texture vertex ids: tid below. It means that when new 24 vertices are defined, i-th vertex is mapped to tid[i]

# from the obj-file:
# texture vertices id's: tid
cells_vt = [[0, 1, 2, 3], [4, 3, 5, 6], [7, 8, 9, 10], [11, 12, 4, 13], [12, 0, 3, 4], [10, 9, 0, 12]]
uvs = [[0.625, 0.5], [0.875, 0.5], [0.875, 0.75], [0.625, 0.75], [0.375, 0.75], [0.625, 1.0], [0.375, 1.0], [0.375, 0.0], [0.625, 0.0], [0.625, 0.25], [0.375, 0.25], [0.125, 0.5], [0.375, 0.5], [0.125, 0.75]]

# flatten texture vertex list
tid = [i for p in cells_vt for i in p]
# and get their uv-coords:
uvs_new = [uvs[i] for i in tid]

# loading a cube with multiple vertices:
C0 = Mesh("coloured_cube.obj")
Cb = Mesh([C0.vertices, C0.cells])  # no texture copied!
# texturing it now:
Cb.texture(tname="cube_face_colours.jpg", tcoords=uvs_new)
show(Cb.lighting("ambient")).close()  # Yuppi!

In practical terms, I realise that multiplying vertices is hard-coded in too many procedures, so I need to do morphing on a non-textured mesh with the vertex order preserved and create a multiple-vertex copy for showing its textured variant. I'll attempt to come with a method textured_clone or smith like this

PS. As for get_uv(p, x, v), well, I suggested it ))
https://forum.image.sc/t/getting-uv-coordinates-of-a-textured-mesh/70816/7

[sergei9838]

OK. I (almost) got the success with the help of load_obj! Below are 3 example files:
cool_cube.obj - a mesh with 2 different materials, look for usemtl lines
cool_cube.mtl - description of the materials. One is cube_face_colours.jpg above, the other is
Cool.jpg - a 'cool' image to be put on one of the faces.

I see that load_obj creates a list of sub-meshes: a new one each time it comes across usemtl key:

Clist=load_obj("cool_cube.obj", mtl_file="cool_cube.mtl")
nm = len(Clist)
print(f'No of meshes: {nm}')
plt = Plotter(shape=(2,2))
for i in range(nm):
    plt.at(i).add(Clist[i].lighting("ambient"))
show(interactive=True).close()

The first mesh is empty: Clist[0].nvertices is 0. Perhaps, it
is there for some reason, maybe for setting the environment like lights, etc. The other are parts of our geometry.
So let's put them all together and enjoy the view!

plt = Plotter()
for i in range(1,nm):
    plt.add(Clist[i].lighting("ambient"))
show().close()

I observe that the default lighting is too strong: the texture appears almost washed out. It should not be a problem to fix.

What I am really missing is correspondence between the newly created vertices and the original ones present in the obj-file. It is needed to write back the obj with the original vertices. I know what it is: it's the flattened list of the vertex indices of the faces in the obj-file (minus 1 because obj numbers them from 1):
The first f-lines in the obj:

usemtl Material
f 1/1 5/2 7/3 3/4
usemtl Cool
f 4/15 3/17 7/18 8/16

Thus Clist[1] vertices 0,1,2,3 are the original vertices 0, 4, 6 and 2
Clist[2] vertices 0,1,2,3 are the original vertices 3, 2, 6 and 7

For this, I need to parse the original obj-file, but maybe the original indices or their re-indexing is already present somewhere in the mesh properties?
The code execution complains that
vtkExtractEdges.cxx:427 INFO| Executing edge extractor: points are renumbered
so maybe it saves somewhere this renumbering?

[sergei9838]

# cool_cube.obj

mtllib cool_cube.mtl
o Cube
v 1.0 1.0 -1.0
v 1.0 -1.0 -1.0
v 1.0 1.0 1.0
v 1.0 -1.0 1.0
v -1.0 1.0 -1.0
v -1.0 -1.0 -1.0
v -1.0 1.0 1.0
v -1.0 -1.0 1.0

vt 0.625 0.5
vt 0.875 0.5
vt 0.875 0.75
vt 0.625 0.75
vt 0.375 0.75
vt 0.625 1.0
vt 0.375 1.0
vt 0.375 0.0
vt 0.625 0.0
vt 0.625 0.25
vt 0.375 0.25
vt 0.125 0.5
vt 0.375 0.5
vt 0.125 0.75
vt 1.0 0.0
vt 0.0 0.0
vt 1.0 1.0
vt 0.0 1.0

usemtl Material
f 1/1 5/2 7/3 3/4

usemtl Cool
f 4/15 3/17 7/18 8/16

usemtl Material
f 8/8 7/9 5/10 6/11
f 6/12 2/13 4/5 8/14
f 2/13 1/1 3/4 4/5
f 6/11 5/10 1/1 2/13

[sergei9838]

# cool_cube.mtl

newmtl Material
d 1
Kd 1 1 1
map_Kd cube_face_colours.jpg

newmtl Cool
d 1
Kd 1 1 1
map_Kd Cool.jpg