io.hh

// Copyright (C) 2008 EPITA Research and Development Laboratory (LRDE)
//
// This file is part of the Milena Library.  This library is free
// software; you can redistribute it and/or modify it under the terms
// of the GNU General Public License version 2 as published by the
// Free Software Foundation.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this library; see the file COPYING.  If not, write to
// the Free Software Foundation, 51 Franklin Street, Fifth Floor,
// Boston, MA 02111-1307, USA.
//
// As a special exception, you may use this file as part of a free
// software library without restriction.  Specifically, if other files
// instantiate templates or use macros or inline functions from this
// file, or you compile this file and link it with other files to
// produce an executable, this file does not by itself cause the
// resulting executable to be covered by the GNU General Public
// License.  This exception does not however invalidate any other
// reasons why the executable file might be covered by the GNU General
// Public License.

#ifndef APPS_MESH_SEGM_SKEL_IO_HH
# define APPS_MESH_SEGM_SKEL_IO_HH


#include <cstdio>

#include <algorithm>

#include <TriMesh.h>

#include <mln/value/rgb8.hh>


// Convert colors float -> uchar
inline unsigned char color2uchar(float p)
{
        return min(max(int(255.0f * p + 0.5f), 0), 255);
}

// Write a bunch of vertices to an ASCII file
inline void write_verts_asc(TriMesh *mesh, FILE *f,
                            const char *before_vert,
                            const char *before_norm,
                            const char *before_color,
                            bool float_color,
                            const char *before_conf,
                            const char *after_line)
{
    for (unsigned i = 0; i < mesh->vertices.size(); i++) {
                fprintf(f, "%s%.7g %.7g %.7g", before_vert,
                                mesh->vertices[i][0],
                                mesh->vertices[i][1],
                                mesh->vertices[i][2]);
                if (!mesh->normals.empty() && before_norm)
                        fprintf(f, "%s%.7g %.7g %.7g", before_norm,
                                mesh->normals[i][0],
                                mesh->normals[i][1],
                                mesh->normals[i][2]);
                if (!mesh->colors.empty() && before_color && float_color)
                        fprintf(f, "%s%.7g %.7g %.7g", before_color,
                                mesh->colors[i][0],
                                mesh->colors[i][1],
                                mesh->colors[i][2]);
                if (!mesh->colors.empty() && before_color && !float_color)
                        fprintf(f, "%s%d %d %d", before_color,
                                color2uchar(mesh->colors[i][0]),
                                color2uchar(mesh->colors[i][1]),
                                color2uchar(mesh->colors[i][2]));
                if (!mesh->confidences.empty() && before_conf)
                        fprintf(f, "%s%.7g", before_conf, mesh->confidences[i]);
                fprintf(f, "%s\n", after_line);
        }
}



/*----------------------.
| OFF with color data.  |
`----------------------*/

inline void write_faces_asc_colored(TriMesh *mesh,
                                    const std::vector<mln::value::rgb8>& colors,
                                    FILE *f,
                                    const char *before_face,
                                    const char *after_line)
{
  mesh->need_faces();
  for (unsigned i = 0; i < mesh->faces.size(); i++)
    {
      fprintf(f, "%s%d %d %d %d %d %d%s\n",
              before_face,
              mesh->faces[i][0], mesh->faces[i][1], mesh->faces[i][2],
              int(colors[i].red()),
              int(colors[i].green()),
              int(colors[i].blue()),
              after_line);
    }
}

inline void write_off_colored(TriMesh *mesh,
                              const std::vector<mln::value::rgb8>& colors,
                              FILE *f)
{
  fprintf(f, "OFF\n");
  mesh->need_faces();
  fprintf(f, "%lu %lu 0\n", (unsigned long) mesh->vertices.size(),
          (unsigned long) mesh->faces.size());
  write_verts_asc(mesh, f, "", 0, 0, false, 0, "");
  write_faces_asc_colored(mesh, colors, f, "3 ", "");
}

/*----------------------.
| OFF with float data.  |
`----------------------*/

inline void write_faces_asc_float(TriMesh *mesh,
                                  const std::vector<float>& values,
                                  FILE *f,
                                  const char *before_face,
                                  const char *after_line)
{
  mesh->need_faces();
  for (unsigned i = 0; i < mesh->faces.size(); i++)
    {
      //            Vertices    Color
      //            -------- ------------
      //            V0 V1 V2  R  G  B  A
      fprintf(f, "%s%d %d %d %f %f %f 1.0%s\n",
              before_face,
              mesh->faces[i][0], mesh->faces[i][1], mesh->faces[i][2],
              values[i], values[i], values[i],
              after_line);
    }
}

inline void write_off_float(TriMesh *mesh, const std::vector<float>& values,
                            FILE *f)
{
  fprintf(f, "OFF\n");
  mesh->need_faces();
  fprintf(f, "%lu %lu 0\n", (unsigned long) mesh->vertices.size(),
          (unsigned long) mesh->faces.size());
  write_verts_asc(mesh, f, "", 0, 0, false, 0, "");
  write_faces_asc_float(mesh, values, f, "3 ", "");
}


/*---------------------------------------.
| OFF without data (``binary values'').  |
`---------------------------------------*/

inline void write_faces_asc_binary(TriMesh *mesh,
                                   const std::vector<bool>& face_value,
                                   FILE *f,
                                   const char *before_face,
                                   const char *after_line)
{
  mesh->need_faces();
  for (unsigned i = 0; i < mesh->faces.size(); i++)
    if (face_value[i])
    {
      fprintf(f, "%s%d %d %d%s\n",
              before_face,
              mesh->faces[i][0], mesh->faces[i][1], mesh->faces[i][2],
              after_line);
    }
}

inline void write_off_binary(TriMesh *mesh,
                             const std::vector<bool>& face_value,
                             FILE *f)
{
  fprintf(f, "OFF\n");
  mesh->need_faces();
  unsigned long nfaces =
    std::count(face_value.begin(), face_value.end(), true);
  fprintf(f, "%lu %lu 0\n", (unsigned long) mesh->vertices.size(), nfaces);
  write_verts_asc(mesh, f, "", 0, 0, false, 0, "");
  write_faces_asc_binary(mesh, face_value, f, "3 ", "");
}

#endif // ! APPS_MESH_SEGM_SKEL_IO_HH

---