From 6abac58deb4e66a6b53fb1887976080fae045ac6 Mon Sep 17 00:00:00 2001 From: Hugues Delorme Date: Wed, 29 Jan 2014 16:59:19 +0100 Subject: [PATCH] Considerable simplify libstl API --- qmake/fougdatax.pro | 3 +- src/internal/libstl/stlb_byte_swap.c | 4 +- src/internal/libstl/stlb_byte_swap.h | 10 +- src/internal/libstl/stlb_rw_common.h | 4 +- src/libstl/stl_format.c | 4 +- src/libstl/stl_geom.h | 14 +++ src/libstl/stl_geom_creator.h | 19 +++ src/libstl/stl_triangle.h | 4 +- src/libstl/stla_read.c | 169 +++++++++++++++------------ src/libstl/stla_read.h | 17 +-- src/libstl/stla_write.c | 23 ++-- src/libstl/stla_write.h | 18 +-- src/libstl/stlb_read.c | 45 ++++--- src/libstl/stlb_read.h | 18 +-- src/libstl/stlb_triangle.h | 13 --- src/libstl/stlb_write.c | 31 +++-- src/libstl/stlb_write.h | 18 +-- src/support/occ_libstl.cpp | 74 ++++++------ src/support/occ_libstl.h | 42 +++---- 19 files changed, 265 insertions(+), 265 deletions(-) create mode 100644 src/libstl/stl_geom.h create mode 100644 src/libstl/stl_geom_creator.h delete mode 100644 src/libstl/stlb_triangle.h diff --git a/qmake/fougdatax.pro b/qmake/fougdatax.pro index 6a39903..714f22d 100644 --- a/qmake/fougdatax.pro +++ b/qmake/fougdatax.pro @@ -59,13 +59,14 @@ contains(DATAX, stl) { HEADERS += \ ../src/libstl/stl_error.h \ ../src/libstl/stl_format.h \ + ../src/libstl/stl_geom.h \ + ../src/libstl/stl_geom_creator.h \ ../src/libstl/stl_global.h \ ../src/libstl/stl_triangle.h \ ../src/libstl/stla_read.h \ ../src/libstl/stla_write.h \ ../src/libstl/stlb_read.h \ ../src/libstl/stlb_write.h \ - ../src/libstl/stlb_triangle.h \ \ ../src/internal/libstl/stlb_byte_swap.h \ ../src/internal/libstl/stlb_rw_common.h diff --git a/src/internal/libstl/stlb_byte_swap.c b/src/internal/libstl/stlb_byte_swap.c index 5cb9e7c..81a9fa8 100644 --- a/src/internal/libstl/stlb_byte_swap.c +++ b/src/internal/libstl/stlb_byte_swap.c @@ -2,10 +2,10 @@ #include "../byte_swap.h" -void foug_stlb_triangle_bswap(foug_stlb_triangle_t* triangle) +void foug_stl_triangle_bswap(foug_stl_triangle_t* triangle) { int i; - uint32_t* uintcoord_ptr = (uint32_t*)&(triangle->data.normal.x); + uint32_t* uintcoord_ptr = (uint32_t*)&(triangle->normal.x); for (i = 0; i < 12; ++i) *(uintcoord_ptr + i) = foug_uint32_bswap(*(uintcoord_ptr + i)); diff --git a/src/internal/libstl/stlb_byte_swap.h b/src/internal/libstl/stlb_byte_swap.h index 943e94d..3b9758d 100644 --- a/src/internal/libstl/stlb_byte_swap.h +++ b/src/internal/libstl/stlb_byte_swap.h @@ -1,9 +1,9 @@ -#ifndef FOUG_INTERNAL_STLB_ENDIAN_H -#define FOUG_INTERNAL_STLB_ENDIAN_H +#ifndef FOUG_INTERNAL_STLB_BYTE_SWAP_H +#define FOUG_INTERNAL_STLB_BYTE_SWAP_H #include "../../global.h" -#include "../../libstl/stlb_triangle.h" +#include "../../libstl/stl_triangle.h" -void foug_stlb_triangle_bswap(foug_stlb_triangle_t* triangle); +void foug_stl_triangle_bswap(foug_stl_triangle_t* triangle); -#endif /* FOUG_INTERNAL_STLB_ENDIAN_H */ +#endif /* FOUG_INTERNAL_STLB_BYTE_SWAP_H */ diff --git a/src/internal/libstl/stlb_rw_common.h b/src/internal/libstl/stlb_rw_common.h index 0ab8275..458bbe6 100644 --- a/src/internal/libstl/stlb_rw_common.h +++ b/src/internal/libstl/stlb_rw_common.h @@ -4,13 +4,13 @@ #include "../../global.h" #include "../../endian.h" #include "../../transfer.h" -#include "../../libstl/stlb_triangle.h" +#include "../../libstl/stl_triangle.h" typedef struct { uint32_t facet_count; uint32_t i_facet_offset; - void (*fix_endian_func)(foug_stlb_triangle_t*); + void (*fix_endian_func)(foug_stl_triangle_t*); } foug_readwrite_helper; int foug_stlb_check_params(const foug_transfer_t* trsf, diff --git a/src/libstl/stl_format.c b/src/libstl/stl_format.c index 83133c1..29188cf 100644 --- a/src/libstl/stl_format.c +++ b/src/libstl/stl_format.c @@ -3,7 +3,7 @@ #include "../endian.h" #include "../internal/byte_codec.h" #include "../internal/byte_swap.h" -#include "stlb_triangle.h" +#include "stl_triangle.h" #include #include @@ -44,7 +44,7 @@ foug_stl_format_t foug_stl_get_format(foug_stream_t *stream, size_t data_size) /* Next token (if exists) must match "solid " */ if (pos < _INTERNAL_FOUG_FIXED_BUFFER_SIZE - && strcmp(fixed_buffer + pos, "solid ") == 0) + && strncmp(fixed_buffer + pos, "solid ", 6) == 0) { return FOUG_STL_ASCII_FORMAT; } diff --git a/src/libstl/stl_geom.h b/src/libstl/stl_geom.h new file mode 100644 index 0000000..f92cfe3 --- /dev/null +++ b/src/libstl/stl_geom.h @@ -0,0 +1,14 @@ +#ifndef FOUG_LIBSTL_STL_GEOM_H +#define FOUG_LIBSTL_STL_GEOM_H + +#include "stl_global.h" +#include "stl_triangle.h" + +typedef struct foug_stl_geom +{ + const void* cookie; + uint32_t triangle_count; + void (*get_triangle_func)(const void*, uint32_t, foug_stl_triangle_t*); +} foug_stl_geom_t; + +#endif /* FOUG_LIBSTL_STL_GEOM_H */ diff --git a/src/libstl/stl_geom_creator.h b/src/libstl/stl_geom_creator.h new file mode 100644 index 0000000..43b4951 --- /dev/null +++ b/src/libstl/stl_geom_creator.h @@ -0,0 +1,19 @@ +#ifndef FOUG_LIBSTL_STL_GEOM_CREATOR_H +#define FOUG_LIBSTL_STL_GEOM_CREATOR_H + +#include "stl_global.h" +#include "stl_triangle.h" + +typedef struct +{ + void* cookie; + + void (*ascii_begin_solid_func)(void*, const char*); /* Optional */ + void (*binary_begin_solid_func)(void*, uint32_t, const uint8_t*); /* Optional */ + + void (*add_triangle_func)(void*, uint32_t, const foug_stl_triangle_t*); /* Optional */ + + void (*end_solid_func) (void*); /* Optional */ +} foug_stl_geom_creator_t; + +#endif /* FOUG_LIBSTL_STL_GEOM_CREATOR_H */ diff --git a/src/libstl/stl_triangle.h b/src/libstl/stl_triangle.h index 14f8b01..17b3c9f 100644 --- a/src/libstl/stl_triangle.h +++ b/src/libstl/stl_triangle.h @@ -17,7 +17,9 @@ typedef struct foug_stl_triangle foug_stl_coords_t v1; foug_stl_coords_t v2; foug_stl_coords_t v3; + uint16_t attribute_byte_count; /* Useful only for STL binary format */ } foug_stl_triangle_t; -#define FOUG_STL_TRIANGLE_RAWSIZE (4 * FOUG_STL_COORDS_RAWSIZE) +#define FOUG_STLA_TRIANGLE_RAWSIZE (4 * FOUG_STL_COORDS_RAWSIZE) +#define FOUG_STLB_TRIANGLE_RAWSIZE (FOUG_STLA_TRIANGLE_RAWSIZE + sizeof(uint16_t)) #endif /* FOUG_DATAX_C_LIBSTL_TRIANGLE_H */ diff --git a/src/libstl/stla_read.c b/src/libstl/stla_read.c index c68b9d2..2576911 100644 --- a/src/libstl/stla_read.c +++ b/src/libstl/stla_read.c @@ -8,6 +8,8 @@ #include #include +#include + /* * * STL ASCII grammar: @@ -77,6 +79,7 @@ typedef enum OUTER_token, SOLID_token, VERTEX_token, + empty_token, unknown_token } foug_stla_token_t; @@ -88,7 +91,7 @@ typedef struct foug_ascii_stream_fwd_iterator_t stream_iterator; _internal_foug_fwd_iterator_cookie_t stream_iterator_cookie; foug_ascii_string_buffer_t string_buffer; - foug_stla_geom_input_t* geom; + foug_stl_geom_creator_t* creator; } foug_stla_parse_data_t; static void foug_stream_fwd_iterator_stla_read_hook(void* cookie, @@ -126,79 +129,89 @@ FOUG_INLINE static void parsing_error(foug_stla_parse_data_t* data) { data->error = 1; data->token = unknown_token; + printf("parsing_error, token: %s\n", data->string_buffer.ptr); +} + +static foug_stla_token_t parsing_find_token(const foug_ascii_string_buffer_t* str_buffer) +{ + const char* word = str_buffer->ptr; + const size_t word_len = str_buffer->len; + + /* Get rid of ill-formed token */ + if (word_len == 0) + return empty_token; + + /* Try to guess if it's a float */ + if (word[0] == '+' || word[0] == '-' || isdigit(word[0])) + return FLOAT_token; + + /* Try to find non "endXxx" token */ + if (word_len >= 4) { + switch (word[0]) { + case 'f': + if (strcmp(word + 1, "acet") == 0) + return FACET_token; + break; + case 'l': + if (strcmp(word + 1, "oop") == 0) + return LOOP_token; + break; + case 'n': + if (strcmp(word + 1, "ormal") == 0) + return NORMAL_token; + break; + case 'o': + if (strcmp(word + 1, "uter") == 0) + return OUTER_token; + break; + case 's': + if (strcmp(word + 1, "olid") == 0) + return SOLID_token; + break; + case 'v': + if (strcmp(word + 1, "ertex") == 0) + return VERTEX_token; + break; + default: + break; + } + } + + /* Might be "end..." token */ + if (word_len >= 7 && strncmp(word, "end", 3) == 0) { + switch (word[3]) { + case 'f': + if (strcmp(word + 4, "acet") == 0) + return ENDFACET_token; + break; + case 'l': + if (strcmp(word + 4, "oop") == 0) + return ENDLOOP_token; + break; + case 's': + if (strcmp(word + 4, "olid") == 0) + return ENDSOLID_token; + break; + default: + break; + } + } + + return ID_token; } static void parsing_advance(foug_stla_parse_data_t* data) { - const char* word = data->string_buffer.ptr; - if (!parsing_can_continue(data)) return; - data->token = unknown_token; - if (foug_eat_word(&data->stream_iterator, &data->string_buffer) == 0) { - const size_t word_len = data->string_buffer.len; - - if (word_len >= 7 && strncmp(word, "end", 3) == 0) { /* Might be "end..." token */ - switch (word[3]) { - case 'f': - if (strcmp(word + 4, "acet") == 0) - data->token = ENDFACET_token; - break; - case 'l': - if (strcmp(word + 4, "oop") == 0) - data->token = ENDLOOP_token; - break; - case 's': - if (strcmp(word + 4, "olid") == 0) - data->token = ENDSOLID_token; - break; - default: - data->token = ID_token; - } /* end switch */ - } - else if (word_len >= 4) { - switch (word[0]) { - case 'f': - if (strcmp(word + 1, "acet") == 0) - data->token = FACET_token; - break; - case 'l': - if (strcmp(word + 1, "oop") == 0) - data->token = LOOP_token; - break; - case 'n': - if (strcmp(word + 1, "ormal") == 0) - data->token = NORMAL_token; - break; - case 'o': - if (strcmp(word + 1, "uter") == 0) - data->token = OUTER_token; - break; - case 's': - if (strcmp(word + 1, "olid") == 0) - data->token = SOLID_token; - break; - case 'v': - if (strcmp(word + 1, "ertex") == 0) - data->token = VERTEX_token; - break; - default: - data->token = unknown_token; - } - } - - if (data->token == unknown_token) { - if (word[0] == '+' || word[0] == '-' || isdigit(word[0])) /* Try to guess if it's a float */ - data->token = FLOAT_token; - else - data->token = ID_token; - } - } - else { + if (foug_eat_word(&data->stream_iterator, &data->string_buffer) == 0) + data->token = parsing_find_token(&data->string_buffer); + else data->token = unknown_token; + + if (data->token == unknown_token) parsing_error(data); - } } static void parsing_eat_token(foug_stla_token_t token, foug_stla_parse_data_t* data) @@ -235,6 +248,7 @@ static void parse_solidname_end(foug_stla_parse_data_t* data) switch (data->token) { case SOLID_token: case ID_token: + case empty_token: break; default: parsing_error(data); @@ -250,8 +264,13 @@ static void parse_beginsolid(foug_stla_parse_data_t* data) case SOLID_token: { parsing_eat_token(SOLID_token, data); parse_solidname_beg(data); - if (parsing_can_continue(data) && data->geom != NULL && data->geom->begin_solid_func != NULL) - data->geom->begin_solid_func(data->geom->cookie, current_token_as_identifier(data)); + if (parsing_can_continue(data) + && data->creator != NULL + && data->creator->ascii_begin_solid_func != NULL) + { + data->creator->ascii_begin_solid_func(data->creator->cookie, + current_token_as_identifier(data)); + } if (data->token == ID_token) parsing_eat_token(ID_token, data); break; @@ -270,8 +289,12 @@ static void parse_endsolid(foug_stla_parse_data_t* data) case ENDSOLID_token: { parsing_eat_token(ENDSOLID_token, data); parse_solidname_end(data); - if (parsing_can_continue(data) && data->geom != NULL && data->geom->end_solid_func != NULL) - data->geom->end_solid_func(data->geom->cookie/*, current_token_as_identifier(data)*/); + if (parsing_can_continue(data) + && data->creator != NULL + && data->creator->end_solid_func != NULL) + { + data->creator->end_solid_func(data->creator->cookie/*, current_token_as_identifier(data)*/); + } if (data->token == ID_token) parsing_eat_token(ID_token, data); break; @@ -331,8 +354,8 @@ static void parse_facets(foug_stla_parse_data_t* data) while (data->token == FACET_token && parsing_can_continue(data)) { parse_facet(data, &facet); - if (data->geom != NULL && data->geom->process_triangle_func != NULL) - data->geom->process_triangle_func(data->geom->cookie, i_facet_offset, &facet); + if (data->creator != NULL && data->creator->add_triangle_func != NULL) + data->creator->add_triangle_func(data->creator->cookie, i_facet_offset, &facet); ++i_facet_offset; } } @@ -354,7 +377,7 @@ static void parse_solid(foug_stla_parse_data_t* data) #define FOUG_STLA_READ_STRING_BUFFER_LEN 512 -int foug_stla_read(foug_stla_geom_input_t* geom, +int foug_stla_read(foug_stl_geom_creator_t *creator, foug_transfer_t *trsf, size_t data_size_hint) { @@ -387,7 +410,7 @@ int foug_stla_read(foug_stla_geom_input_t* geom, parse_data.string_buffer.len = 0; parse_data.string_buffer.max_len = FOUG_STLA_READ_STRING_BUFFER_LEN; - parse_data.geom = geom; + parse_data.creator = creator; parsing_advance(&parse_data); parse_solid(&parse_data); diff --git a/src/libstl/stla_read.h b/src/libstl/stla_read.h index 919194d..8f4e1ef 100644 --- a/src/libstl/stla_read.h +++ b/src/libstl/stla_read.h @@ -2,21 +2,12 @@ #define FOUG_DATAX_C_LIBSTL_STLA_READ_H #include "stl_global.h" -#include "stl_triangle.h" +#include "stl_geom_creator.h" #include "../transfer.h" -/* foug_stla_geom_input */ -typedef struct -{ - void* cookie; - void (*begin_solid_func) (void*, const char*); /* Optional */ - void (*process_triangle_func)(void*, uint32_t, const foug_stl_triangle_t*); - void (*end_solid_func) (void*); /* Optional */ -} foug_stla_geom_input_t; - /* foug_stla_read() */ -FOUG_DATAX_LIBSTL_EXPORT int foug_stla_read(foug_stla_geom_input_t* geom, - foug_transfer_t* trsf, - size_t data_size_hint); +FOUG_DATAX_LIBSTL_EXPORT int foug_stla_read(foug_stl_geom_creator_t* creator, + foug_transfer_t* trsf, + size_t data_size_hint); #endif /* FOUG_DATAX_C_LIBSTL_STLA_READ_H */ diff --git a/src/libstl/stla_write.c b/src/libstl/stla_write.c index c5bdb93..49c17fe 100644 --- a/src/libstl/stla_write.c +++ b/src/libstl/stla_write.c @@ -30,14 +30,16 @@ static char* foug_write_string(char* buffer, const char* str) { - strcpy(buffer, str); - return buffer + strlen(str); + const char* safe_str = str != NULL ? str : ""; + strcpy(buffer, safe_str); + return buffer + strlen(safe_str); } static char* foug_write_string_eol(char* buffer, const char* str) { - const size_t len = strlen(str); - strncpy(buffer, str, len); + const char* safe_str = str != NULL ? str : ""; + const size_t len = strlen(safe_str); + strncpy(buffer, safe_str, len); buffer[len] = '\n'; return buffer + len + 1; } @@ -85,7 +87,7 @@ static char* foug_write_coords(char* buffer, return buffer + sprintf(buffer, coords_format, coords->x, coords->y, coords->z); } -static foug_bool_t foug_tansfer_flush_buffer(foug_transfer_t* trsf, size_t n) +static foug_bool_t foug_transfer_flush_buffer(foug_transfer_t* trsf, size_t n) { return foug_stream_write(&trsf->stream, trsf->buffer, sizeof(char), n) == n; } @@ -96,6 +98,7 @@ static foug_bool_t foug_tansfer_flush_buffer(foug_transfer_t* trsf, size_t n) * * \param geom Defines the custom geometry to write * \param trsf Defines needed objects (stream, buffer, ...) for the writing operation +* \param solid_name May be NULL to generate default name * \param real32_prec The maximum number of significant digits * * \return Error code @@ -108,11 +111,11 @@ static foug_bool_t foug_tansfer_flush_buffer(foug_transfer_t* trsf, size_t n) * \retval FOUG_DATAX_STREAM_ERROR For any writing error * \retval FOUG_DATAX_TASK_STOPPED_ERROR If the operation was interrupted foug_task_control */ -int foug_stla_write(foug_stla_geom_output_t* geom, +int foug_stla_write(foug_stl_geom_t* geom, foug_transfer_t* trsf, + const char* solid_name, uint8_t real32_prec) { - const char* solid_name = geom != NULL && geom->solid_name != NULL ? geom->solid_name : ""; const uint32_t total_facet_count = geom != NULL ? geom->triangle_count : 0; uint32_t written_facet_count = 0; const uint32_t buffer_facet_count = trsf != NULL ? trsf->buffer_size / FOUG_STLA_FACET_SIZE_P2 : 0; @@ -145,7 +148,7 @@ int foug_stla_write(foug_stla_geom_output_t* geom, { buffer_iterator = foug_write_string(buffer_iterator, "solid "); buffer_iterator = foug_write_string_eol(buffer_iterator, solid_name); - if (!foug_tansfer_flush_buffer(trsf, buffer_iterator - (char*)trsf->buffer)) + if (!foug_transfer_flush_buffer(trsf, buffer_iterator - (char*)trsf->buffer)) return FOUG_DATAX_STREAM_ERROR; } @@ -182,7 +185,7 @@ int foug_stla_write(foug_stla_geom_output_t* geom, buffer_iterator = foug_write_string_eol(buffer_iterator, "endfacet"); } /* end for (ibuffer_facet) */ - if (!foug_tansfer_flush_buffer(trsf, buffer_iterator - (char*)trsf->buffer)) + if (!foug_transfer_flush_buffer(trsf, buffer_iterator - (char*)trsf->buffer)) error = FOUG_DATAX_STREAM_ERROR; /* Task control */ @@ -199,7 +202,7 @@ int foug_stla_write(foug_stla_geom_output_t* geom, if (foug_datax_no_error(error)) { buffer_iterator = foug_write_string(trsf->buffer, "endsolid "); buffer_iterator = foug_write_string_eol(buffer_iterator, solid_name); - if (!foug_tansfer_flush_buffer(trsf, buffer_iterator - (char*)trsf->buffer)) + if (!foug_transfer_flush_buffer(trsf, buffer_iterator - (char*)trsf->buffer)) error = FOUG_DATAX_STREAM_ERROR; } diff --git a/src/libstl/stla_write.h b/src/libstl/stla_write.h index 1d6f749..05e487d 100644 --- a/src/libstl/stla_write.h +++ b/src/libstl/stla_write.h @@ -2,21 +2,13 @@ #define FOUG_DATAX_C_LIBSTL_STLA_WRITE_H #include "stl_global.h" -#include "stl_triangle.h" +#include "stl_geom.h" #include "../transfer.h" -/* Custom geometry expressed with STL ascii interface */ -typedef struct foug_stla_geom_output -{ - const char* solid_name; /* May be NULL to generate default name */ - uint32_t triangle_count; - const void* cookie; - void (*get_triangle_func)(const void*, uint32_t, foug_stl_triangle_t*); -} foug_stla_geom_output_t; - /* Write geometry in the STL ascii format */ -FOUG_DATAX_LIBSTL_EXPORT int foug_stla_write(foug_stla_geom_output_t* geom, - foug_transfer_t* trsf, - uint8_t real32_prec); +FOUG_DATAX_LIBSTL_EXPORT int foug_stla_write(foug_stl_geom_t* geom, + foug_transfer_t* trsf, + const char* solid_name, + uint8_t real32_prec); #endif /* FOUG_DATAX_C_LIBSTL_STLA_WRITE_H */ diff --git a/src/libstl/stlb_read.c b/src/libstl/stlb_read.c index 56b4cb9..656d91c 100644 --- a/src/libstl/stlb_read.c +++ b/src/libstl/stlb_read.c @@ -12,9 +12,9 @@ #include FOUG_INLINE static void read_triangle_memcpy(const uint8_t* buffer, - foug_stlb_triangle_t* triangle) + foug_stl_triangle_t* triangle) { - /* *triangle = *((foug_stlb_triangle_t*)(buffer)); */ + /* *triangle = *((foug_stl_triangle_t*)(buffer)); */ memcpy(triangle, buffer, FOUG_STLB_TRIANGLE_RAWSIZE); } @@ -23,29 +23,28 @@ static void read_coords_alignsafe(const uint8_t* buffer, foug_stl_coords_t* coor memcpy(coords, buffer, FOUG_STL_COORDS_RAWSIZE); } -static void read_triangle_alignsafe(const uint8_t* buffer, foug_stlb_triangle_t* triangle) +static void read_triangle_alignsafe(const uint8_t* buffer, foug_stl_triangle_t* triangle) { - read_coords_alignsafe(buffer, &triangle->data.normal); - read_coords_alignsafe(buffer + 1*FOUG_STL_COORDS_RAWSIZE, &triangle->data.v1); - read_coords_alignsafe(buffer + 2*FOUG_STL_COORDS_RAWSIZE, &triangle->data.v2); - read_coords_alignsafe(buffer + 3*FOUG_STL_COORDS_RAWSIZE, &triangle->data.v3); + read_coords_alignsafe(buffer, &triangle->normal); + read_coords_alignsafe(buffer + 1*FOUG_STL_COORDS_RAWSIZE, &triangle->v1); + read_coords_alignsafe(buffer + 2*FOUG_STL_COORDS_RAWSIZE, &triangle->v2); + read_coords_alignsafe(buffer + 3*FOUG_STL_COORDS_RAWSIZE, &triangle->v3); memcpy(&triangle->attribute_byte_count, buffer + 4*FOUG_STL_COORDS_RAWSIZE, sizeof(uint16_t)); } -static void foug_stlb_read_facets(foug_stlb_geom_input_t* geom, +static void foug_stlb_read_facets(foug_stl_geom_creator_t* creator, const uint8_t* buffer, const foug_readwrite_helper* rparams) { const uint32_t facet_count = rparams->facet_count; const uint32_t i_facet_offset = rparams->i_facet_offset; - foug_stlb_triangle_t triangle; - uint32_t buffer_offset; - uint32_t i_facet; + foug_stl_triangle_t triangle; + uint32_t buffer_offset = 0; + uint32_t i_facet = 0; - if (geom == NULL || geom->process_triangle_func == NULL) + if (creator == NULL || creator->add_triangle_func == NULL) return; - buffer_offset = 0; for (i_facet = 0; i_facet < facet_count; ++i_facet) { /* Decode data */ #ifdef FOUG_STLB_READWRITE_ALIGNSAFE @@ -59,14 +58,11 @@ static void foug_stlb_read_facets(foug_stlb_geom_input_t* geom, rparams->fix_endian_func(&triangle); /* Declare triangle */ - geom->process_triangle_func(geom->cookie, - i_facet_offset + i_facet, - &triangle.data, - triangle.attribute_byte_count); + creator->add_triangle_func(creator->cookie, i_facet_offset + i_facet, &triangle); } } -int foug_stlb_read(foug_stlb_geom_input_t* geom, +int foug_stlb_read(foug_stl_geom_creator_t *creator, foug_transfer_t* trsf, foug_endianness_t byte_order) { @@ -84,7 +80,7 @@ int foug_stlb_read(foug_stlb_geom_input_t* geom, /* Initialize rparams */ memset(&rparams, 0, sizeof(foug_readwrite_helper)); if (host_byte_order != byte_order) - rparams.fix_endian_func = foug_stlb_triangle_bswap; + rparams.fix_endian_func = foug_stl_triangle_bswap; /* Read header */ if (foug_stream_read(&trsf->stream, header_data, 1, FOUG_STLB_HEADER_SIZE) @@ -102,8 +98,8 @@ int foug_stlb_read(foug_stlb_geom_input_t* geom, total_facet_count = foug_uint32_bswap(total_facet_count); /* Callback to notify triangle count and header data */ - if (geom != NULL && geom->begin_triangles_func != NULL) - geom->begin_triangles_func(geom->cookie, total_facet_count, header_data); + if (creator != NULL && creator->binary_begin_solid_func != NULL) + creator->binary_begin_solid_func(creator->cookie, total_facet_count, header_data); /* Read triangles */ while (foug_datax_no_error(error) @@ -123,7 +119,7 @@ int foug_stlb_read(foug_stlb_geom_input_t* geom, if (foug_datax_no_error(error)) { uint8_t progress_pc; - foug_stlb_read_facets(geom, trsf->buffer, &rparams); + foug_stlb_read_facets(creator, trsf->buffer, &rparams); rparams.i_facet_offset += rparams.facet_count; progress_pc = foug_percentage(0, total_facet_count, rparams.i_facet_offset); if (!foug_task_control_handle_progress(&trsf->task_control, progress_pc)) @@ -132,9 +128,10 @@ int foug_stlb_read(foug_stlb_geom_input_t* geom, } /* end while */ if (foug_datax_no_error(error) - && geom != NULL && geom->end_triangles_func != NULL) + && creator != NULL + && creator->end_solid_func != NULL) { - geom->end_triangles_func(geom->cookie); + creator->end_solid_func(creator->cookie); } if (foug_datax_no_error(error) && rparams.i_facet_offset != total_facet_count) diff --git a/src/libstl/stlb_read.h b/src/libstl/stlb_read.h index 1654775..f8128fd 100644 --- a/src/libstl/stlb_read.h +++ b/src/libstl/stlb_read.h @@ -2,23 +2,13 @@ #define FOUG_DATAX_C_LIBSTL_STLB_READ_H #include "stl_global.h" -#include "stlb_triangle.h" +#include "stl_geom_creator.h" #include "../endian.h" #include "../transfer.h" -/* foug_stlb_geom_input */ -typedef struct -{ - void* cookie; - /* All function pointers can be safely set to NULL */ - void (*begin_triangles_func) (void*, uint32_t, const uint8_t*); - void (*process_triangle_func)(void*, uint32_t, const foug_stl_triangle_t*, uint16_t); - void (*end_triangles_func) (void*); -} foug_stlb_geom_input_t; - /* foug_stlb_read() */ -FOUG_DATAX_LIBSTL_EXPORT int foug_stlb_read(foug_stlb_geom_input_t* geom, - foug_transfer_t* trsf, - foug_endianness_t byte_order); +FOUG_DATAX_LIBSTL_EXPORT int foug_stlb_read(foug_stl_geom_creator_t* creator, + foug_transfer_t* trsf, + foug_endianness_t byte_order); #endif /* FOUG_DATAX_C_LIBSTL_STLB_READ_H */ diff --git a/src/libstl/stlb_triangle.h b/src/libstl/stlb_triangle.h deleted file mode 100644 index 500db37..0000000 --- a/src/libstl/stlb_triangle.h +++ /dev/null @@ -1,13 +0,0 @@ -#ifndef FOUG_DATAX_C_LIBSTL_STLB_TRIANGLE_H -#define FOUG_DATAX_C_LIBSTL_STLB_TRIANGLE_H - -#include "stl_triangle.h" - -typedef struct foug_stlb_triangle -{ - foug_stl_triangle_t data; - uint16_t attribute_byte_count; -} foug_stlb_triangle_t; -#define FOUG_STLB_TRIANGLE_RAWSIZE (FOUG_STL_TRIANGLE_RAWSIZE + sizeof(uint16_t)) - -#endif /* FOUG_DATAX_C_LIBSTL_STLB_TRIANGLE_H */ diff --git a/src/libstl/stlb_write.c b/src/libstl/stlb_write.c index 8ac0675..7253491 100644 --- a/src/libstl/stlb_write.c +++ b/src/libstl/stlb_write.c @@ -10,7 +10,7 @@ #include -FOUG_INLINE static void write_triangle_memcpy(const foug_stlb_triangle_t* triangle, +FOUG_INLINE static void write_triangle_memcpy(const foug_stl_triangle_t* triangle, uint8_t* buffer) { memcpy(buffer, triangle, FOUG_STLB_TRIANGLE_RAWSIZE); @@ -21,22 +21,22 @@ static void write_coords_alignsafe(const foug_stl_coords_t* coords, uint8_t* buf memcpy(buffer, coords, FOUG_STL_COORDS_RAWSIZE); } -static void write_triangle_alignsafe(const foug_stlb_triangle_t* triangle, uint8_t* buffer) +static void write_triangle_alignsafe(const foug_stl_triangle_t* triangle, uint8_t* buffer) { - write_coords_alignsafe(&triangle->data.normal, buffer); - write_coords_alignsafe(&triangle->data.v1, buffer + 1*FOUG_STL_COORDS_RAWSIZE); - write_coords_alignsafe(&triangle->data.v2, buffer + 2*FOUG_STL_COORDS_RAWSIZE); - write_coords_alignsafe(&triangle->data.v3, buffer + 3*FOUG_STL_COORDS_RAWSIZE); + write_coords_alignsafe(&triangle->normal, buffer); + write_coords_alignsafe(&triangle->v1, buffer + 1*FOUG_STL_COORDS_RAWSIZE); + write_coords_alignsafe(&triangle->v2, buffer + 2*FOUG_STL_COORDS_RAWSIZE); + write_coords_alignsafe(&triangle->v3, buffer + 3*FOUG_STL_COORDS_RAWSIZE); memcpy(buffer + 4*FOUG_STL_COORDS_RAWSIZE, &triangle->attribute_byte_count, sizeof(uint16_t)); } -static void foug_stlb_write_facets(const foug_stlb_geom_output_t* geom, +static void foug_stlb_write_facets(const foug_stl_geom_t* geom, uint8_t* buffer, const foug_readwrite_helper* wparams) { const uint32_t facet_count = wparams->facet_count; const uint32_t i_facet_offset = wparams->i_facet_offset; - foug_stlb_triangle_t triangle; + foug_stl_triangle_t triangle; uint32_t buffer_offset = 0; uint32_t i_facet = 0; @@ -45,9 +45,7 @@ static void foug_stlb_write_facets(const foug_stlb_geom_output_t* geom, triangle.attribute_byte_count = 0; for (i_facet = i_facet_offset; i_facet < (i_facet_offset + facet_count); ++i_facet) { - geom->get_triangle_func(geom->cookie, i_facet, &triangle.data); - if (geom->get_attr_byte_count_func != NULL) - geom->get_attr_byte_count_func(geom->cookie, i_facet, &triangle.attribute_byte_count); + geom->get_triangle_func(geom->cookie, i_facet, &triangle); if (wparams->fix_endian_func != NULL) wparams->fix_endian_func(&triangle); @@ -62,8 +60,9 @@ static void foug_stlb_write_facets(const foug_stlb_geom_output_t* geom, } /* end for */ } -int foug_stlb_write(const foug_stlb_geom_output_t* geom, +int foug_stlb_write(const foug_stl_geom_t *geom, foug_transfer_t* trsf, + const uint8_t *header_data, foug_endianness_t byte_order) { foug_readwrite_helper wparams; @@ -81,16 +80,12 @@ int foug_stlb_write(const foug_stlb_geom_output_t* geom, /* Initialize wparams */ memset(&wparams, 0, sizeof(foug_readwrite_helper)); if (foug_host_endianness() != byte_order) - wparams.fix_endian_func = foug_stlb_triangle_bswap; + wparams.fix_endian_func = foug_stl_triangle_bswap; wparams.facet_count = trsf->buffer_size / FOUG_STLB_TRIANGLE_RAWSIZE; /* Write header */ { - const uint8_t* header_data = NULL; - if (geom->header != NULL) { - header_data = geom->header; - } - else { + if (header_data == NULL) { /* Use buffer to store an empty header (filled with zeroes) */ memset(trsf->buffer, 0, FOUG_STLB_HEADER_SIZE); header_data = (const uint8_t*)trsf->buffer; diff --git a/src/libstl/stlb_write.h b/src/libstl/stlb_write.h index 0be5618..a437dee 100644 --- a/src/libstl/stlb_write.h +++ b/src/libstl/stlb_write.h @@ -2,22 +2,14 @@ #define FOUG_DATAX_C_LIBSTL_STLB_WRITE_H #include "stl_global.h" -#include "stlb_triangle.h" +#include "stl_geom.h" #include "../endian.h" #include "../transfer.h" -typedef struct -{ - const uint8_t* header; /* May be NULL if empty header */ - uint32_t triangle_count; - const void* cookie; - void (*get_triangle_func)(const void*, uint32_t, foug_stl_triangle_t*); - void (*get_attr_byte_count_func)(const void*, uint32_t, uint16_t*); /* Optional : may be NULL */ -} foug_stlb_geom_output_t; - /* foug_stlb_write() */ -FOUG_DATAX_LIBSTL_EXPORT int foug_stlb_write(const foug_stlb_geom_output_t* geom, - foug_transfer_t* trsf, - foug_endianness_t byte_order); +FOUG_DATAX_LIBSTL_EXPORT int foug_stlb_write(const foug_stl_geom_t* geom, + foug_transfer_t* trsf, + const uint8_t* header_data, + foug_endianness_t byte_order); #endif /* FOUG_DATAX_C_LIBSTL_STLB_WRITE_H */ diff --git a/src/support/occ_libstl.cpp b/src/support/occ_libstl.cpp index d20e75e..3d853ba 100644 --- a/src/support/occ_libstl.cpp +++ b/src/support/occ_libstl.cpp @@ -20,14 +20,12 @@ static void occmesh_add_triangle(void* cookie, const foug_stl_triangle_t* tri) { StlMesh_Mesh* mesh = static_cast(cookie); - if (tri_id == 0) mesh->AddDomain(); - - const int uId = mesh->AddOnlyNewVertex(tri->v1.x, tri->v1.y, tri->v1.z); - const int vId = mesh->AddOnlyNewVertex(tri->v2.x, tri->v2.y, tri->v2.z); - const int wId = mesh->AddOnlyNewVertex(tri->v3.x, tri->v3.y, tri->v3.z); - mesh->AddTriangle(uId, vId, wId, tri->normal.x, tri->normal.y, tri->normal.z); + mesh->AddTriangle(mesh->AddOnlyNewVertex(tri->v1.x, tri->v1.y, tri->v1.z), + mesh->AddOnlyNewVertex(tri->v2.x, tri->v2.y, tri->v2.z), + mesh->AddOnlyNewVertex(tri->v3.x, tri->v3.y, tri->v3.z), + tri->normal.x, tri->normal.y, tri->normal.z); } static void occmesh_get_triangle(const void* cookie, @@ -35,7 +33,7 @@ static void occmesh_get_triangle(const void* cookie, foug_stl_triangle_t* triangle) { const foug_OccStlMeshDomain* meshCookie = static_cast(cookie); - const StlMesh_SequenceOfMeshTriangle& occTriangles = meshCookie->mesh->Triangles(meshCookie->domainId); + const StlMesh_SequenceOfMeshTriangle& occTriangles = meshCookie->mesh()->Triangles(meshCookie->domainId()); const Handle_StlMesh_MeshTriangle& occTri = occTriangles.Value(tri_id + 1); Standard_Integer v1; Standard_Integer v2; @@ -48,7 +46,7 @@ static void occmesh_get_triangle(const void* cookie, triangle->normal.y = float(yN); triangle->normal.z = float(zN); - const TColgp_SequenceOfXYZ& vertices = meshCookie->mesh->Vertices(meshCookie->domainId); + const TColgp_SequenceOfXYZ& vertices = meshCookie->mesh()->Vertices(meshCookie->domainId()); const gp_XYZ& coordsV1 = vertices.Value(v1); const gp_XYZ& coordsV2 = vertices.Value(v2); const gp_XYZ& coordsV3 = vertices.Value(v3); @@ -65,51 +63,47 @@ static void occmesh_get_triangle(const void* cookie, triangle->v3.z = float(coordsV3.Z()); } -static void occmesh_stlb_add_triangle(void* cookie, - uint32_t tri_id, - const foug_stl_triangle_t* triangle, - uint16_t /*attr_byte_count*/) -{ - occmesh_add_triangle(cookie, tri_id, triangle); -} - } // namespace internal -void foug_stla_geom_input_set_occmesh(foug_stla_geom_input_t* input, const Handle_StlMesh_Mesh &mesh) +void foug_stl_occmesh_geom(foug_stl_geom_t *geom, + const foug_OccStlMeshDomain &meshCookie) { - input->cookie = internal::occMeshPtr(mesh); - memset(input, 0, sizeof(foug_stla_geom_input_t)); - input->process_triangle_func = internal::occmesh_add_triangle; + std::memset(geom, 0, sizeof(foug_stl_geom_t)); + geom->cookie = &meshCookie; + geom->triangle_count = meshCookie.mesh()->NbTriangles(meshCookie.domainId()); + geom->get_triangle_func = internal::occmesh_get_triangle; } -void foug_stla_geom_output_set_occmesh(foug_stla_geom_output_t *output, - const foug_OccStlMeshDomain &meshCookie) +void foug_stl_occmesh_geom_creator(foug_stl_geom_creator_t *creator, + const Handle_StlMesh_Mesh &mesh) { - output->cookie = &meshCookie; - memset(output, 0, sizeof(foug_stla_geom_output_t)); - output->triangle_count = meshCookie.mesh->NbTriangles(meshCookie.domainId); - output->get_triangle_func = internal::occmesh_get_triangle; + std::memset(creator, 0, sizeof(foug_stl_geom_creator_t)); + creator->cookie = internal::occMeshPtr(mesh); + creator->add_triangle_func = internal::occmesh_add_triangle; } -void foug_stlb_geom_input_set_occmesh(foug_stlb_geom_input_t* input, const Handle_StlMesh_Mesh &mesh) +foug_OccStlMeshDomain::foug_OccStlMeshDomain(const Handle_StlMesh_Mesh &stlMesh, int domId) + : m_mesh(stlMesh), + m_domainId(domId) { - input->cookie = internal::occMeshPtr(mesh); - memset(input, 0, sizeof(foug_stlb_geom_input_t)); - input->process_triangle_func = internal::occmesh_stlb_add_triangle; } -void foug_stlb_geom_output_set_occmesh(foug_stlb_geom_output_t* output, - const foug_OccStlMeshDomain &meshCookie) +const Handle_StlMesh_Mesh &foug_OccStlMeshDomain::mesh() const { - static const char occMeshBinaryHeader[] = "Generated by libfougdatax, occmesh geometry"; - output->cookie = &meshCookie; - output->header = reinterpret_cast(occMeshBinaryHeader); - output->triangle_count = meshCookie.mesh->NbTriangles(meshCookie.domainId); - output->get_triangle_func = internal::occmesh_get_triangle; + return m_mesh; } -foug_OccStlMeshDomain::foug_OccStlMeshDomain(const Handle_StlMesh_Mesh &stlMesh, int stlDomainId) - : mesh(stlMesh), - domainId(stlDomainId) +void foug_OccStlMeshDomain::setMesh(const Handle_StlMesh_Mesh &stlMesh) { + m_mesh = stlMesh; +} + +int foug_OccStlMeshDomain::domainId() const +{ + return m_domainId; +} + +void foug_OccStlMeshDomain::setDomainId(int domId) +{ + m_domainId = domId; } diff --git a/src/support/occ_libstl.h b/src/support/occ_libstl.h index c852056..63ab86a 100644 --- a/src/support/occ_libstl.h +++ b/src/support/occ_libstl.h @@ -10,31 +10,31 @@ extern "C" { } #include -struct FOUG_LIBSUPPORT_EXPORT foug_OccStlMeshDomain +class FOUG_LIBSUPPORT_EXPORT foug_OccStlMeshDomain { - foug_OccStlMeshDomain(const Handle_StlMesh_Mesh& stlMesh, int stlDomainId = 1); - Handle_StlMesh_Mesh mesh; - int domainId; +public: + foug_OccStlMeshDomain(const Handle_StlMesh_Mesh& stlMesh, int domId = 1); + + const Handle_StlMesh_Mesh& mesh() const; + void setMesh(const Handle_StlMesh_Mesh& stlMesh); + + int domainId() const; + void setDomainId(int domId); + +private: + Handle_StlMesh_Mesh m_mesh; + int m_domainId; + + Standard_Integer m_triVertexId[3]; + Standard_Real m_triNormalCoords[3]; }; -/* ASCII STL */ +FOUG_LIBSUPPORT_EXPORT +void foug_stl_occmesh_geom(foug_stl_geom_t* geom, + const foug_OccStlMeshDomain& meshCookie); FOUG_LIBSUPPORT_EXPORT -void foug_stla_geom_input_set_occmesh(foug_stla_geom_input_t* input, - const Handle_StlMesh_Mesh& mesh); - -FOUG_LIBSUPPORT_EXPORT -void foug_stla_geom_output_set_occmesh(foug_stla_geom_output_t* output, - const foug_OccStlMeshDomain& meshCookie); - -/* Binary STL */ - -FOUG_LIBSUPPORT_EXPORT -void foug_stlb_geom_input_set_occmesh(foug_stlb_geom_input_t* input, - const Handle_StlMesh_Mesh& mesh); - -FOUG_LIBSUPPORT_EXPORT -void foug_stlb_geom_output_set_occmesh(foug_stlb_geom_output_t* output, - const foug_OccStlMeshDomain& meshCookie); +void foug_stl_occmesh_geom_creator(foug_stl_geom_creator_t* creator, + const Handle_StlMesh_Mesh& mesh); #endif /* FOUG_SUPPORT_OCC_LIBSTL_H */