← Back to branch summary

~ubuntu-branches/ubuntu/utopic/slic3r/utopic

« back to all changes in this revision

Viewing changes to xs/src/admesh/stl_io.c

  • Committer: Package Import Robot
  • Author(s): Chow Loong Jin
  • Date: 2014-06-17 01:27:26 UTC
  • Revision ID: package-import@ubuntu.com-20140617012726-2wrs4zdo251nr4vg
Tags: upstream-1.1.4+dfsg
Import upstream version 1.1.4+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
xs/src/admesh/stl_io.c
 
1
/*  ADMesh -- process triangulated solid meshes
 
2
 *  Copyright (C) 1995, 1996 Anthony D. Martin
 
3
 *
 
4
 *  This program is free software; you can redistribute it and/or modify
 
5
 *  it under the terms of the GNU General Public License as published by
 
6
 *  the Free Software Foundation; either version 2, or (at your option)
 
7
 *  any later version.
 
8
 *
 
9
 *  This program is distributed in the hope that it will be useful,
 
10
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
 *  GNU General Public License for more details.
 
13
 *
 
14
 *  You should have received a copy of the GNU General Public License
 
15
 *  along with this program; if not, write to the Free Software
 
16
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
17
 *  
 
18
 *  Questions, comments, suggestions, etc to <amartin@engr.csulb.edu>
 
19
 */
 
20
 
 
21
#include <cstring>
 
22
#include <stdlib.h>
 
23
#include "stl.h"
 
24
 
 
25
#if !defined(SEEK_SET)
 
26
#define SEEK_SET 0
 
27
#define SEEK_CUR 1
 
28
#define SEEK_END 2
 
29
#endif
 
30
 
 
31
static void stl_put_little_int(FILE *fp, int value);
 
32
static void stl_put_little_float(FILE *fp, float value_in);
 
33
 
 
34
void
 
35
stl_print_edges(stl_file *stl, FILE *file)
 
36
{
 
37
  int i;
 
38
  int edges_allocated;
 
39
 
 
40
  edges_allocated = stl->stats.number_of_facets * 3;
 
41
  for(i = 0; i < edges_allocated; i++)
 
42
    {
 
43
      fprintf(file, "%d, %f, %f, %f, %f, %f, %f\n",
 
44
              stl->edge_start[i].facet_number, 
 
45
              stl->edge_start[i].p1.x, stl->edge_start[i].p1.y, 
 
46
              stl->edge_start[i].p1.z, stl->edge_start[i].p2.x, 
 
47
              stl->edge_start[i].p2.y, stl->edge_start[i].p2.z);
 
48
    }
 
49
}
 
50
 
 
51
 
 
52
void
 
53
stl_stats_out(stl_file *stl, FILE *file, char *input_file)
 
54
{
 
55
  fprintf(file, "\n\
 
56
================= Results produced by ADMesh version 0.95 ================\n");
 
57
  fprintf(file, "\
 
58
Input file         : %s\n", input_file);
 
59
  if(stl->stats.type == binary)
 
60
    {
 
61
      fprintf(file, "\
 
62
File type          : Binary STL file\n");
 
63
    }
 
64
  else
 
65
    {
 
66
      fprintf(file, "\
 
67
File type          : ASCII STL file\n");
 
68
    }      
 
69
  fprintf(file, "\
 
70
Header             : %s\n", stl->stats.header);
 
71
  fprintf(file, "============== Size ==============\n");
 
72
  fprintf(file, "Min X = % f, Max X = % f\n", 
 
73
          stl->stats.min.x, stl->stats.max.x);
 
74
  fprintf(file, "Min Y = % f, Max Y = % f\n", 
 
75
          stl->stats.min.y, stl->stats.max.y);
 
76
  fprintf(file, "Min Z = % f, Max Z = % f\n", 
 
77
          stl->stats.min.z, stl->stats.max.z);
 
78
  
 
79
  fprintf(file, "\
 
80
========= Facet Status ========== Original ============ Final ====\n");
 
81
  fprintf(file, "\
 
82
Number of facets                 : %5d               %5d\n", 
 
83
          stl->stats.original_num_facets, stl->stats.number_of_facets);
 
84
  fprintf(file, "\
 
85
Facets with 1 disconnected edge  : %5d               %5d\n", 
 
86
          stl->stats.facets_w_1_bad_edge, stl->stats.connected_facets_2_edge -
 
87
          stl->stats.connected_facets_3_edge);
 
88
  fprintf(file, "\
 
89
Facets with 2 disconnected edges : %5d               %5d\n", 
 
90
          stl->stats.facets_w_2_bad_edge, stl->stats.connected_facets_1_edge -
 
91
          stl->stats.connected_facets_2_edge);
 
92
  fprintf(file, "\
 
93
Facets with 3 disconnected edges : %5d               %5d\n", 
 
94
          stl->stats.facets_w_3_bad_edge, stl->stats.number_of_facets -
 
95
          stl->stats.connected_facets_1_edge);
 
96
  fprintf(file, "\
 
97
Total disconnected facets        : %5d               %5d\n", 
 
98
          stl->stats.facets_w_1_bad_edge + stl->stats.facets_w_2_bad_edge +
 
99
          stl->stats.facets_w_3_bad_edge, stl->stats.number_of_facets - 
 
100
          stl->stats.connected_facets_3_edge);
 
101
          
 
102
  fprintf(file, 
 
103
"=== Processing Statistics ===     ===== Other Statistics =====\n");
 
104
  fprintf(file, "\
 
105
Number of parts       : %5d        Volume   : % f\n",
 
106
          stl->stats.number_of_parts, stl->stats.volume);
 
107
  fprintf(file, "\
 
108
Degenerate facets     : %5d\n", stl->stats.degenerate_facets);
 
109
  fprintf(file, "\
 
110
Edges fixed           : %5d\n", stl->stats.edges_fixed);
 
111
  fprintf(file, "\
 
112
Facets removed        : %5d\n", stl->stats.facets_removed);
 
113
  fprintf(file, "\
 
114
Facets added          : %5d\n", stl->stats.facets_added);
 
115
  fprintf(file, "\
 
116
Facets reversed       : %5d\n", stl->stats.facets_reversed);
 
117
  fprintf(file, "\
 
118
Backwards edges       : %5d\n", stl->stats.backwards_edges);
 
119
  fprintf(file, "\
 
120
Normals fixed         : %5d\n", stl->stats.normals_fixed);
 
121
}
 
122
 
 
123
void
 
124
stl_write_ascii(stl_file *stl, const char *file, const char *label)
 
125
{
 
126
  int       i;
 
127
  FILE      *fp;
 
128
  char      *error_msg;
 
129
  
 
130
  
 
131
  /* Open the file */
 
132
  fp = fopen(file, "w");
 
133
  if(fp == NULL)
 
134
    {
 
135
      error_msg = (char*)
 
136
        malloc(81 + strlen(file)); /* Allow 80 chars+file size for message */
 
137
      sprintf(error_msg, "stl_write_ascii: Couldn't open %s for writing",
 
138
              file);
 
139
      perror(error_msg);
 
140
      free(error_msg);
 
141
      exit(1);
 
142
    }
 
143
  
 
144
  fprintf(fp, "solid  %s\n", label);
 
145
  
 
146
  for(i = 0; i < stl->stats.number_of_facets; i++)
 
147
    {
 
148
      fprintf(fp, "  facet normal % .8E % .8E % .8E\n",
 
149
              stl->facet_start[i].normal.x, stl->facet_start[i].normal.y,
 
150
              stl->facet_start[i].normal.z);
 
151
      fprintf(fp, "    outer loop\n");
 
152
      fprintf(fp, "      vertex % .8E % .8E % .8E\n",
 
153
              stl->facet_start[i].vertex[0].x, stl->facet_start[i].vertex[0].y,
 
154
              stl->facet_start[i].vertex[0].z);
 
155
      fprintf(fp, "      vertex % .8E % .8E % .8E\n",
 
156
              stl->facet_start[i].vertex[1].x, stl->facet_start[i].vertex[1].y,
 
157
              stl->facet_start[i].vertex[1].z);
 
158
      fprintf(fp, "      vertex % .8E % .8E % .8E\n",
 
159
              stl->facet_start[i].vertex[2].x, stl->facet_start[i].vertex[2].y,
 
160
              stl->facet_start[i].vertex[2].z);
 
161
      fprintf(fp, "    endloop\n");
 
162
      fprintf(fp, "  endfacet\n");
 
163
    }
 
164
  
 
165
  fprintf(fp, "endsolid  %s\n", label);
 
166
  
 
167
  fclose(fp);
 
168
}
 
169
 
 
170
void
 
171
stl_print_neighbors(stl_file *stl, char *file)
 
172
{
 
173
  int i;
 
174
  FILE *fp;
 
175
  char *error_msg;
 
176
 
 
177
  /* Open the file */
 
178
  fp = fopen(file, "w");
 
179
  if(fp == NULL)
 
180
    {
 
181
      error_msg = (char*)
 
182
        malloc(81 + strlen(file)); /* Allow 80 chars+file size for message */
 
183
      sprintf(error_msg, "stl_print_neighbors: Couldn't open %s for writing",
 
184
              file);
 
185
      perror(error_msg);
 
186
      free(error_msg);
 
187
      exit(1);
 
188
    }
 
189
 
 
190
  for(i = 0; i < stl->stats.number_of_facets; i++)
 
191
    {
 
192
      fprintf(fp, "%d, %d,%d, %d,%d, %d,%d\n",
 
193
              i, 
 
194
              stl->neighbors_start[i].neighbor[0],
 
195
              (int)stl->neighbors_start[i].which_vertex_not[0],
 
196
              stl->neighbors_start[i].neighbor[1], 
 
197
              (int)stl->neighbors_start[i].which_vertex_not[1],
 
198
              stl->neighbors_start[i].neighbor[2],
 
199
              (int)stl->neighbors_start[i].which_vertex_not[2]);
 
200
    }
 
201
    fclose(fp);
 
202
}
 
203
 
 
204
static void
 
205
stl_put_little_int(FILE *fp, int value_in)
 
206
{
 
207
  int new_value;
 
208
  union 
 
209
    {
 
210
      int  int_value;
 
211
      char char_value[4];
 
212
    } value;
 
213
  
 
214
  value.int_value = value_in;
 
215
  
 
216
  new_value  = value.char_value[0] & 0xFF;
 
217
  new_value |= (value.char_value[1] & 0xFF) << 0x08;
 
218
  new_value |= (value.char_value[2] & 0xFF) << 0x10;
 
219
  new_value |= (value.char_value[3] & 0xFF) << 0x18;
 
220
  fwrite(&new_value, sizeof(int), 1, fp);
 
221
}
 
222
 
 
223
static void
 
224
stl_put_little_float(FILE *fp, float value_in)
 
225
{
 
226
  int new_value;
 
227
  union 
 
228
    {
 
229
      float float_value;
 
230
      char  char_value[4];
 
231
    } value;
 
232
  
 
233
  value.float_value = value_in;
 
234
  
 
235
  new_value  = value.char_value[0] & 0xFF;
 
236
  new_value |= (value.char_value[1] & 0xFF) << 0x08;
 
237
  new_value |= (value.char_value[2] & 0xFF) << 0x10;
 
238
  new_value |= (value.char_value[3] & 0xFF) << 0x18;
 
239
  fwrite(&new_value, sizeof(int), 1, fp);
 
240
}
 
241
 
 
242
 
 
243
void
 
244
stl_write_binary(stl_file *stl, const char *file, const char *label)
 
245
{
 
246
  FILE      *fp;
 
247
  int       i;
 
248
  char      *error_msg;
 
249
 
 
250
  
 
251
  /* Open the file */
 
252
  fp = fopen(file, "wb");
 
253
  if(fp == NULL)
 
254
    {
 
255
      error_msg = (char*)
 
256
        malloc(81 + strlen(file)); /* Allow 80 chars+file size for message */
 
257
      sprintf(error_msg, "stl_write_binary: Couldn't open %s for writing",
 
258
              file);
 
259
      perror(error_msg);
 
260
      free(error_msg);
 
261
      exit(1);
 
262
    }
 
263
 
 
264
  fprintf(fp, "%s", label);
 
265
  for(i = strlen(label); i < LABEL_SIZE; i++) putc(0, fp);
 
266
 
 
267
  fseek(fp, LABEL_SIZE, SEEK_SET);
 
268
 
 
269
  stl_put_little_int(fp, stl->stats.number_of_facets);
 
270
  
 
271
  for(i = 0; i < stl->stats.number_of_facets; i++)
 
272
    {
 
273
      stl_put_little_float(fp, stl->facet_start[i].normal.x);
 
274
      stl_put_little_float(fp, stl->facet_start[i].normal.y);
 
275
      stl_put_little_float(fp, stl->facet_start[i].normal.z);
 
276
      stl_put_little_float(fp, stl->facet_start[i].vertex[0].x);
 
277
      stl_put_little_float(fp, stl->facet_start[i].vertex[0].y);
 
278
      stl_put_little_float(fp, stl->facet_start[i].vertex[0].z);
 
279
      stl_put_little_float(fp, stl->facet_start[i].vertex[1].x);
 
280
      stl_put_little_float(fp, stl->facet_start[i].vertex[1].y);
 
281
      stl_put_little_float(fp, stl->facet_start[i].vertex[1].z);
 
282
      stl_put_little_float(fp, stl->facet_start[i].vertex[2].x);
 
283
      stl_put_little_float(fp, stl->facet_start[i].vertex[2].y);
 
284
      stl_put_little_float(fp, stl->facet_start[i].vertex[2].z);
 
285
      fputc(stl->facet_start[i].extra[0], fp);
 
286
      fputc(stl->facet_start[i].extra[1], fp);
 
287
    }
 
288
  
 
289
  fclose(fp);
 
290
}
 
291
 
 
292
void
 
293
stl_write_vertex(stl_file *stl, int facet, int vertex)
 
294
{
 
295
  printf("  vertex %d/%d % .8E % .8E % .8E\n", vertex, facet,
 
296
         stl->facet_start[facet].vertex[vertex].x,
 
297
         stl->facet_start[facet].vertex[vertex].y,
 
298
         stl->facet_start[facet].vertex[vertex].z);
 
299
}
 
300
 
 
301
void
 
302
stl_write_facet(stl_file *stl, char *label, int facet)
 
303
{
 
304
  printf("facet (%d)/ %s\n", facet, label);
 
305
  stl_write_vertex(stl, facet, 0);
 
306
  stl_write_vertex(stl, facet, 1);
 
307
  stl_write_vertex(stl, facet, 2);
 
308
}
 
309
 
 
310
void
 
311
stl_write_edge(stl_file *stl, char *label, stl_hash_edge edge)
 
312
{
 
313
  printf("edge (%d)/(%d) %s\n", edge.facet_number, edge.which_edge, label);
 
314
  if(edge.which_edge < 3)
 
315
    {
 
316
      stl_write_vertex(stl, edge.facet_number, edge.which_edge % 3);
 
317
      stl_write_vertex(stl, edge.facet_number, (edge.which_edge + 1) % 3);
 
318
    }
 
319
  else
 
320
    {
 
321
      stl_write_vertex(stl, edge.facet_number, (edge.which_edge + 1) % 3);
 
322
      stl_write_vertex(stl, edge.facet_number, edge.which_edge % 3);
 
323
    }
 
324
}
 
325
 
 
326
void
 
327
stl_write_neighbor(stl_file *stl, int facet)
 
328
{
 
329
  printf("Neighbors %d: %d, %d, %d ;  %d, %d, %d\n", facet,
 
330
         stl->neighbors_start[facet].neighbor[0],
 
331
         stl->neighbors_start[facet].neighbor[1],
 
332
         stl->neighbors_start[facet].neighbor[2],
 
333
         stl->neighbors_start[facet].which_vertex_not[0],
 
334
         stl->neighbors_start[facet].which_vertex_not[1],
 
335
         stl->neighbors_start[facet].which_vertex_not[2]);
 
336
}
 
337
 
 
338
void
 
339
stl_write_quad_object(stl_file *stl, char *file)
 
340
{
 
341
  FILE      *fp;
 
342
  int       i;
 
343
  int       j;
 
344
  char      *error_msg;
 
345
  stl_vertex connect_color;
 
346
  stl_vertex uncon_1_color;
 
347
  stl_vertex uncon_2_color;
 
348
  stl_vertex uncon_3_color;
 
349
  stl_vertex color;
 
350
  
 
351
  /* Open the file */
 
352
  fp = fopen(file, "w");
 
353
  if(fp == NULL)
 
354
    {
 
355
      error_msg = (char*)
 
356
        malloc(81 + strlen(file)); /* Allow 80 chars+file size for message */
 
357
      sprintf(error_msg, "stl_write_quad_object: Couldn't open %s for writing",
 
358
              file);
 
359
      perror(error_msg);
 
360
      free(error_msg);
 
361
      exit(1);
 
362
    }
 
363
 
 
364
  connect_color.x = 0.0;
 
365
  connect_color.y = 0.0;
 
366
  connect_color.z = 1.0;
 
367
  uncon_1_color.x = 0.0;
 
368
  uncon_1_color.y = 1.0;
 
369
  uncon_1_color.z = 0.0;
 
370
  uncon_2_color.x = 1.0;
 
371
  uncon_2_color.y = 1.0;
 
372
  uncon_2_color.z = 1.0;
 
373
  uncon_3_color.x = 1.0;
 
374
  uncon_3_color.y = 0.0;
 
375
  uncon_3_color.z = 0.0;
 
376
 
 
377
  fprintf(fp, "CQUAD\n");
 
378
  for(i = 0; i < stl->stats.number_of_facets; i++)
 
379
    {
 
380
      j = ((stl->neighbors_start[i].neighbor[0] == -1) +
 
381
           (stl->neighbors_start[i].neighbor[1] == -1) +
 
382
           (stl->neighbors_start[i].neighbor[2] == -1));
 
383
      if(j == 0)
 
384
        {
 
385
          color = connect_color;
 
386
        }
 
387
      else if(j == 1)
 
388
        {
 
389
          color = uncon_1_color;
 
390
        }
 
391
      else if(j == 2)
 
392
        {
 
393
          color = uncon_2_color;
 
394
        }
 
395
      else
 
396
        {
 
397
          color = uncon_3_color;
 
398
        }
 
399
      fprintf(fp, "%f %f %f    %1.1f %1.1f %1.1f 1\n", 
 
400
              stl->facet_start[i].vertex[0].x,
 
401
              stl->facet_start[i].vertex[0].y, 
 
402
              stl->facet_start[i].vertex[0].z, color.x, color.y, color.z);
 
403
      fprintf(fp, "%f %f %f    %1.1f %1.1f %1.1f 1\n",
 
404
              stl->facet_start[i].vertex[1].x,
 
405
              stl->facet_start[i].vertex[1].y, 
 
406
              stl->facet_start[i].vertex[1].z, color.x, color.y, color.z);
 
407
      fprintf(fp, "%f %f %f    %1.1f %1.1f %1.1f 1\n",
 
408
              stl->facet_start[i].vertex[2].x,
 
409
              stl->facet_start[i].vertex[2].y, 
 
410
              stl->facet_start[i].vertex[2].z, color.x, color.y, color.z);
 
411
      fprintf(fp, "%f %f %f    %1.1f %1.1f %1.1f 1\n",
 
412
              stl->facet_start[i].vertex[2].x,
 
413
              stl->facet_start[i].vertex[2].y, 
 
414
              stl->facet_start[i].vertex[2].z, color.x, color.y, color.z);
 
415
    }
 
416
  fclose(fp);
 
417
}
 
418
  
 
419
void
 
420
stl_write_dxf(stl_file *stl, char *file, char *label)
 
421
{
 
422
  int       i;
 
423
  FILE      *fp;
 
424
  char      *error_msg;
 
425
  
 
426
  
 
427
  /* Open the file */
 
428
  fp = fopen(file, "w");
 
429
  if(fp == NULL)
 
430
    {
 
431
      error_msg = (char*)
 
432
        malloc(81 + strlen(file)); /* Allow 80 chars+file size for message */
 
433
      sprintf(error_msg, "stl_write_ascii: Couldn't open %s for writing",
 
434
              file);
 
435
      perror(error_msg);
 
436
      free(error_msg);
 
437
      exit(1);
 
438
    }
 
439
  
 
440
  fprintf(fp, "999\n%s\n", label);
 
441
  fprintf(fp, "0\nSECTION\n2\nHEADER\n0\nENDSEC\n");
 
442
  fprintf(fp, "0\nSECTION\n2\nTABLES\n0\nTABLE\n2\nLAYER\n70\n1\n\
 
443
0\nLAYER\n2\n0\n70\n0\n62\n7\n6\nCONTINUOUS\n0\nENDTAB\n0\nENDSEC\n");
 
444
  fprintf(fp, "0\nSECTION\n2\nBLOCKS\n0\nENDSEC\n");
 
445
  
 
446
  fprintf(fp, "0\nSECTION\n2\nENTITIES\n");
 
447
 
 
448
  for(i = 0; i < stl->stats.number_of_facets; i++)
 
449
    {
 
450
      fprintf(fp, "0\n3DFACE\n8\n0\n");
 
451
      fprintf(fp, "10\n%f\n20\n%f\n30\n%f\n",
 
452
              stl->facet_start[i].vertex[0].x, stl->facet_start[i].vertex[0].y,
 
453
              stl->facet_start[i].vertex[0].z);
 
454
      fprintf(fp, "11\n%f\n21\n%f\n31\n%f\n",
 
455
              stl->facet_start[i].vertex[1].x, stl->facet_start[i].vertex[1].y,
 
456
              stl->facet_start[i].vertex[1].z);
 
457
      fprintf(fp, "12\n%f\n22\n%f\n32\n%f\n",
 
458
              stl->facet_start[i].vertex[2].x, stl->facet_start[i].vertex[2].y,
 
459
              stl->facet_start[i].vertex[2].z);
 
460
      fprintf(fp, "13\n%f\n23\n%f\n33\n%f\n",
 
461
              stl->facet_start[i].vertex[2].x, stl->facet_start[i].vertex[2].y,
 
462
              stl->facet_start[i].vertex[2].z);
 
463
    }
 
464
  
 
465
  fprintf(fp, "0\nENDSEC\n0\nEOF\n");
 
466
  
 
467
  fclose(fp);
 
468
}