[vtkusers] GTS Wrapper?

[Dominik Szczerba]

The idea was to have a GTS functionality inside VTK. It will be somewhat
slow though as each time a conversion will be needed. But e.g. boolean
operations might be wrapped in an optimal fashion, i.e., connect an
input, connect multiple sources, define the operations via a (kind of)
calculator expression, update, and only at the end convert back to VTK.
Point inside surface queries might perform similarly
(BuildInternalRepresentation()...).

-- Dominik

On Tue, 2009-07-21 at 15:21 +0900, HIRAKI Hideaki wrote:
> On Sat, 18 Jul 2009, hardc0rps wrote:
> > I was just wondering if anyone has successfully wrapped the Gnu Triangulated
> > Surface Library (GTS - http://gts.sourceforge.net) into VTK (with boolean
> > operations between vtkpolydata in mind)?
> 
> What do you mean by "wrap"? The attached is what I wrote to convert between
> vtkPolyData and GTS surface a few years ago. I hope this helps.
> plain text document attachment (vtkgts.cpp)
> extern "C" {
> #include "glib.h"
> #include "gts.h"
> extern GtsSurface * read_vtk (gchar *);
> extern void write_vtk (GtsSurface *, gchar *);
> }
> #include "vtkPolyData.h"
> #include "vtkCellArray.h"
> #include "vtkPolyDataReader.h"
> #include "vtkTriangleFilter.h"
> #include "vtkPolyDataWriter.h"
> #ifndef vtkFloatingPointType
> #define vtkFloatingPointType float
> #endif
> 
> void vtk2gts (vtkPolyData * input, GtsSurface * output)
> {
>   GtsVertex ** vertices;
> 
>   g_return_if_fail(output != NULL);
>   if (g_hash_table_size(output->faces) != 0)
>     g_warning("overwriting surface");
>   input->Update();
>   input->BuildLinks();
> 
>   vertices = (GtsVertex **)
>     g_malloc(input->GetNumberOfPoints() * sizeof(GtsVertex *));
>   for (vtkIdType i = 0; i < input->GetNumberOfPoints(); ++i) {
>     vtkFloatingPointType x[3];
>     input->GetPoint(i, x);
>     vertices[i] = gts_vertex_new(output->vertex_class, x[0], x[1], x[2]);
>   }
>   for (vtkIdType i = 0; i < input->GetNumberOfCells(); ++i) {
>     vtkIdType npts, * pts;
>     input->GetCellPoints(i, npts, pts);
>     if (npts != 3) {
>       g_warning("skipping no triangle cell");
>       continue;
>     }
>     GtsEdge * newedges[3];
>     for (gint j = 0; j < 3; ++j) {
>       vtkIdType v1 = pts[j], v2 = pts[(j+1) % 3];
>       newedges[j] = gts_edge_new(output->edge_class,
>                                  vertices[v1], vertices[v2]);
>       if (gts_segment_is_duplicate(GTS_SEGMENT(newedges[j]))) {
>         GtsSegment * tmp = gts_segment_is_duplicate(GTS_SEGMENT(newedges[j]));
>         gts_object_destroy(GTS_OBJECT(newedges[j]));
>         newedges[j] = GTS_EDGE(tmp);
>         g_return_if_fail(gts_segment_is_duplicate(GTS_SEGMENT(newedges[j])) ==
>                          NULL);
>       }
>     }
>     gts_surface_add_face(output,
>                          gts_face_new(output->face_class,
>                                       newedges[0], newedges[1], newedges[2]));
>   }
>   g_free(vertices);
> }
> 
> static void gts2vtk_insert_point (GtsPoint * p, vtkPoints * points)
> {
>   points->InsertNextPoint(p->x, p->y, p->z);
>   GTS_OBJECT(p)->reserved = GUINT_TO_POINTER(points->GetNumberOfPoints() - 1);
> }
> static void gts2vtk_insert_triangle (GtsTriangle * t, vtkCellArray * polys)
> {
>   GtsVertex * v1, * v2, * v3;
>   gts_triangle_vertices(t, &v1, &v2, &v3);
>   polys->InsertNextCell(3);
>   polys->InsertCellPoint(GPOINTER_TO_UINT(GTS_OBJECT(v1)->reserved));
>   polys->InsertCellPoint(GPOINTER_TO_UINT(GTS_OBJECT(v2)->reserved));
>   polys->InsertCellPoint(GPOINTER_TO_UINT(GTS_OBJECT(v3)->reserved));
> }
> void gts2vtk (GtsSurface * input, vtkPolyData * output)
> {
>   output->UpdateInformation();
>   if (output->GetNumberOfPoints() != 0)
>     g_warning("overwriting polydata");
> 
>   vtkPoints *points = vtkPoints::New();
>   vtkCellArray *polys = vtkCellArray::New();
>   gts_surface_foreach_vertex(input, (GtsFunc) &gts2vtk_insert_point, points);
>   gts_surface_foreach_face(input, (GtsFunc) &gts2vtk_insert_triangle, polys);
>   gts_surface_foreach_vertex(input, (GtsFunc) gts_object_reset_reserved, NULL);
>   output->SetPoints(points);
>   points->Delete();
>   output->SetPolys(polys);
>   polys->Delete();
> }
> 
> GtsSurface * read_vtk (gchar * filename)
> {
>   GtsSurface * s = gts_surface_new(gts_surface_class(), gts_face_class(),
>                                    gts_edge_class(), gts_vertex_class());
>   vtkPolyDataReader * reader = vtkPolyDataReader::New();
>   reader->SetFileName(filename);
>   vtkTriangleFilter * triangle = vtkTriangleFilter::New();
>   triangle->SetInput(reader->GetOutput());
>   vtk2gts(triangle->GetOutput(), s);
>   triangle->Delete();
>   reader->Delete();
>   return s;
> }
> 
> void write_vtk (GtsSurface * s, gchar * filename)
> {
>   vtkPolyData * output = vtkPolyData::New();
>   gts2vtk(s, output);
>   vtkPolyDataWriter * writer = vtkPolyDataWriter::New();
>   writer->SetFileTypeToBinary();
>   writer->SetFileName(filename);
>   writer->SetInput(output);
>   writer->Write();
>   writer->Delete();
>   output->Delete();
> }
> plain text document attachment (main.cpp)
> extern "C" {
> #include <stdio.h>
> #include "gts.h"
> extern GtsSurface * read_vtk(gchar *);
> extern void write_vtk(GtsSurface *, gchar *);
> }
> 
> int main(int argc, char * argv[]){
>   if (argc != 3) {
>     fprintf(stderr, "Usage: %s input.vtk output.vtk > output.gts\n", argv[0]);
>     return 1;
>   }
>   GtsSurface * s = read_vtk(argv[1]);
>   gts_surface_write(s, stdout);
>   write_vtk(s, argv[2]);
>   return 0;
> }
> _______________________________________________
> Powered by www.kitware.com
> 
> Visit other Kitware open-source projects at http://www.kitware.com/opensource/opensource.html
> 
> Please keep messages on-topic and check the VTK FAQ at: http://www.vtk.org/Wiki/VTK_FAQ
> 
> Follow this link to subscribe/unsubscribe:
> http://www.vtk.org/mailman/listinfo/vtkusers