kurtz le pirate <kur### [at] gmailcom> wrote:
> On 22/11/2021 17:23, kurtz le pirate wrote:
> > Hello,
> >
> > I have a surface defined by a set of points <x,y,z> and for each point,
> > its color.
> >
> > In your opinion, which object/method is the most appropriate to
> > represent such a surface?
>
>
> I'm moving slowly. I can now build my surface by generating a mesh from
> my set of points exactly as for a height_field.
> But I'm still struggling with the color story.
>
> I have this scheme on the <x,z> plane
>
> +--> z
> |
> V
> x
>
>      |     |     |
> --- * --- * --- * ---
>      |     |     |
> --- * --- * --- * ---
>      |     |     |
> --- * --- * --- * ---
>      |     |     |
> --- * --- * --- * ---
>      |     |     |
>
>
> Each "*" is my points. This points are on a "square grid".
> I convert this grid to triangle. I get :
>
>      |     |     |
> --- * --- * --- * ---
>      |   / |   / |
>      |  /  |  /  |  /
>      | /   | /   | /
> --- * --- * --- * ---
>    / |   / |   / |
>   /  |  /  |  /  |  /
> /   | /   | /   | /
> --- * --- * --- * ---
>    / |   / |   / |
>   /  |  /  |  /  |  /
> /   | /   | /   | /
> --- * --- * --- * ---
>      |     |     |
>
> I obtain a set of triangles schematized below.
> These triangles compose the mesh which is easy to display.
>
> But ... for the color, I still don't know how to do it :(
> The color is "at" a point "*". impossible to find out how to give the
> color to which triangle.
>
>
> One more time, any suggestion ?
>
>
>
>
>
> --
> Kurtz le pirate
> Compagnie de la Banquise

Hi Kurtz,

I've written the script below to show you how to create a mesh2 object from a
parametric expression of your surface and texture (I don't know how you have
defined your surface, I hope you'll figure out how to adapt the macro with
something else than parametric surfaces if needed).

Pascal

-----------------------------------------------------------------------
#version 3.8;

// Given that you have a parametric expression of the surface a follow:
// Inputs:
//   a, b: two floats, the two parameters of the parametric surface.
//         The range of values for a and b depends on the surface equation
//         but I think it's a good idea to impose it to be [0.0, 1.0] and
//         scale it as necessary here, as it avoid having to adapt the
//         CreateMesh macro below each time you change the FunShape macro
// Output:
//   Return a 3D vector, the coordinates of the surface for the given
//   parameters.
#macro FunShape(a, b)
  <a, cos(a * pi) * sin(b * pi), b>
#end

// In the exact same fashion as for the parametric shape, lets suppose you have
// a parametric expression of the texture components (here I consider only the
// rgb color, but it could be extended as needed to other texture components)
// Inputs:
//   a, b: two floats, the two parameters of the parametric surface (the same
//         as FunShape)
// Output:
//   Return a 3D vector, the rgb color of the surface for the given parameters
#macro FunColor(a, b)
  <a, 0.0, b>
#end

// You may also have an explicit expression of the normals of the surface, but
// if you don't you can get an approximation for free from the surface equation
// as follow:
// Inputs:
//   a, b: two floats, the two parameters of the parametric surface
// Output:
//   Return a 3D vector, the normal vector of the surface for the given
//   parameters.
#macro FunShapeNormal(a, b)
  // shapeEpsilon must be set to a small value in comparison to the range
  // of values for the parameters a and b. Here too, imposing a and b in
  // [0.0, 1.0] avoid having to update shapeEpsilon each time FunShape changes
  #local shapeEpsilon = 0.01;
  vcross(
    FunShape(a + shapeEpsilon, b) - FunShape(a, b),
    FunShape(a, b + shapeEpsilon) - FunShape(a, b))
#end

// The macro creating the textured mesh2 object from the parametric expression
// of your surface and texture
#macro CreateMesh()
  // Define the resolution of your grid, the higher the nicer the heavier
  #local nbStepU = 100;
  // You'd probably like to set the same resolution along the two parameters
  // but nothing forbid choose different ones
  #local nbStepV = nbStepU;
  // Starts the mesh2 object
  mesh2 {
    // Calculate the number of vertices
    #local nbVertex = (nbStepU + 1) * (nbStepV + 1);
    // Start the vertices definition
    vertex_vectors {
      nbVertex,
      // Loop on the steps along the parameters
      #local a = 0;
      #while (a <= nbStepU)
        #local b = 0;
        #while (b <= nbStepV)
          // Get the parameters in [0.0, 1.0] from the current steps and
          // calculate and add the coordinates of the vertex
          FunShape(a / nbStepU , b / nbStepV)
          #local b = b + 1;
        #end
        #local a = a + 1;
      #end
    // End the vertices definition
    }
    // Start the normals definition
    normal_vectors {
      // There is one normal per vertex, hence the reuse of nbVertex
      nbVertex,
      // Loop on the steps along the parameters
      #local a = 0;
      #while (a <= nbStepU)
        #local b = 0;
        #while (b <= nbStepV)
          // Get the parameters in [0.0, 1.0] from the current steps and
          // calculate and add the normal
          FunShapeNormal(a / nbStepU , b / nbStepV)
          #local b = b + 1;
        #end
        #local a = a + 1;
      #end
    // End the normal definition
    }
    // Start the textures definition
    texture_list {
      // There is one texture per vertex, hence the reuse of nbVertex
      nbVertex,
      // Loop on the steps along the parameters
      #local a = 0;
      #while (a <= nbStepU)
        #local b = 0;
        #while (b <= nbStepV)
          // Get the parameters in [0.0, 1.0] from the current steps and
          // calculate and add the texture. Here it could be extend with
          // other parametric functions for the finish{} parameters for
          // example
          texture { pigment { rgb FunColor(a / nbStepU , b / nbStepV) }}
          #local b = b + 1;
        #end
        #local a = a + 1;
      #end
    // End the textures definition
    }
    // Start the faces definition
    face_indices {
      // Get the number of faces, one step along the two parameters defines a
      // polyline of 4 vertices which can be split in two triangles
      #local nbFace = nbStepU * nbStepV * 2;
      nbFace ,
      // There are two ways to split the polyline in two triangles, alternating
      // regularly between them gives much better visual results. Set a flag
      // to manage that.
      #local flipEdge = 0;
      // Loop on the steps along the parameters
      #local a = 0;
      #while (a < nbStepU)
        #local b = 0;
        #while (b < nbStepV)
          // Calculate the indices of the four vertices of the polyline
          // corresponding to the current steps
          #local indexVertices = array {
            a * (nbStepV + 1) + b,
            a * (nbStepV + 1) + b + 1,
            (a + 1) * (nbStepV + 1) + b,
            (a + 1) * (nbStepV + 1) + b + 1,
            };
          // Switch between the two ways of splitting the polyline
          #if (flipEdge = 0)
            // Add the first face definition
            <indexVertices[0],indexVertices[1],indexVertices[3]>,
            // Add the texture indices, as we have conveniently defined the
            // texture in the same order as the vertices, their indices are
            // identical
            indexVertices[0],indexVertices[1],indexVertices[3]
            // Same for the second face definition
            <indexVertices[0],indexVertices[3],indexVertices[2]>,
            indexVertices[0],indexVertices[3],indexVertices[2]
          #else
            // Same as flipEdge=1 but with the other combination of indices
            <indexVertices[0],indexVertices[1],indexVertices[2]>,
            indexVertices[0],indexVertices[1],indexVertices[2]
            <indexVertices[1],indexVertices[3],indexVertices[2]>,
            indexVertices[1],indexVertices[3],indexVertices[2]
          #end
          // Flip the splitting
          #local flipEdge = 1 - flipEdge;
          #local b = b + 1;
        #end
        #local a = a + 1;
      #end
    // End the faces definition
    }
  // End the mesh2 object
  }
#end

// Instantiate the mesh
object {
  CreateMesh()
  translate -0.5*x-0.5*z
}

// Dummy settings for test rendering
global_settings {assumed_gamma 1.0}
background { color rgb 0 }
camera { location 1.5 look_at 0 }
light_source { 1.5 color rgb 1 }
-----------------------------------------------------------------------

Post a reply to this message

Attachments:
Download 'surface2mesh.jpg' (21 KB)

Preview of image 'surface2mesh.jpg'