Commit 73fe625d authored by Stenger, Florian's avatar Stenger, Florian
Browse files

meshconv v3.10

parent e07b5a8e
......@@ -5,8 +5,8 @@ Copyright (c) 2008-2017 Technische Universität Dresden
All rights reserved.
Author: Florian Stenger
Technische Universität Dresden - short TUD - has the exclusive
rights to license this product under the following license.
Technische Universität Dresden - short TUD - has the exclusive rights to license this
product under the following license.
Usage is permitted provided that the following conditions are met:
1. The usage in academic institutions and private use is granted free of charge
......
......@@ -3,7 +3,7 @@
// Author: Florian Stenger
// This file is part of meshconv. See also license.txt in the distribution-folder.
#include "meshconv.h"
#include "src/meshconv.h"
using namespace std;
using namespace meshconv;
......
No preview for this file type
......@@ -191,7 +191,8 @@ void box_boundary(Mesh &m, int x0, int x1, int y0, int y1, int z0, int z1){
vector<vector<vector<int> > >* box_boundary_periodic(Mesh &m, int *dimensions){
int cnt_lower, cnt_upper, lower[3], upper[3];
Vertex new_face;
vector<int> new_value(m.dim_of_elements + 1);
vector<int> new_value(2 * m.dim_of_elements + 1);
vector<int> ordered_new_value(m.dim_of_elements + 1);
vector<vector<vector<int> > > *result = new vector<vector<vector<int> > >(m.dim_of_world);
rebuild_element_indices(m);
Vertex max_value, min_value;
......@@ -212,13 +213,15 @@ vector<vector<vector<int> > >* box_boundary_periodic(Mesh &m, int *dimensions){
new_face = Vertex(0.0, 0.0, 0.0);
for(int i = 0; i < m.dim_of_elements; ++i){
new_value[i + 1] = upper[i];
new_face += m.vertices[it->v[upper[i]]];
new_value[i + 1 + m.dim_of_elements] = it->v[upper[i]];
new_face += m.vertices[new_value[i + 1 + m.dim_of_elements]];
}
}else if(cnt_lower == m.dim_of_elements){
new_face = Vertex(0.0, 0.0, 0.0);
for(int i = 0; i < m.dim_of_elements; ++i){
new_value[i + 1] = lower[i];
new_face += m.vertices[it->v[lower[i]]];
new_value[i + 1 + m.dim_of_elements] = it->v[lower[i]];
new_face += m.vertices[new_value[i + 1 + m.dim_of_elements]];
}
}else{
continue;
......@@ -227,16 +230,36 @@ vector<vector<vector<int> > >* box_boundary_periodic(Mesh &m, int *dimensions){
//element has a face on boundary
new_face /= m.dim_of_elements;
new_face[e] = 0.0;
new_value[0] = it->index;
ordered_new_value[0] = it->index;
vector<pair<Vertex, vector<int> >*> find_result = bfaces[e].find(new_face);
if(find_result.size() > 1){
error("Some boundary-face occurrs more than twice in one dimension.");
}
if(find_result.empty()){
new_value[0] = it->index;
bfaces[e].insert(new_face, new_value);
}else{
(*result)[e].push_back(find_result[0]->second);
(*result)[e].push_back(new_value);
vector<int> &other_value = find_result[0]->second;
//! correct ordering of local indices
for(int i = 1; i <= m.dim_of_elements; ++i){
for(int j = 1; j <= m.dim_of_elements; ++j){
int w = 0;
for(; w < m.dim_of_world; ++w){
if(w == e) continue;
if(abs(m.vertices[new_value[j + m.dim_of_elements]][w]
- m.vertices[other_value[i + m.dim_of_elements]][w]) > epsilon){
break;
}
}
if(w == m.dim_of_world){
ordered_new_value[i] = new_value[j];
break;
}
}
}
other_value.resize(m.dim_of_elements + 1);
(*result)[e].push_back(other_value);
(*result)[e].push_back(ordered_new_value);
}
}
}
......@@ -260,11 +283,11 @@ void selection_boundary_2d(Mesh &m, Mesh &n, int boundary_index){
back.init(&m);
back.attach_mesh(&n);
for(it=m.elements.begin(); it!=m.elements.end(); ++it){
for(face=0; face<3; ++face){
for(it = m.elements.begin(); it != m.elements.end(); ++it){
for(face = 0; face < 3; ++face){
if(it->b[face] < 0){
a = 0;
for(i=0; i<2; ++i){
for(i = 0; i < 2; ++i){
if(i == face) ++a;
face_el.v[i] = it->v[a++];
}
......@@ -309,11 +332,11 @@ void selection_boundary_3d(Mesh &m, Mesh &n, int boundary_index){
back.init(&m);
back.attach_mesh(&n);
for(it=m.elements.begin(); it!=m.elements.end(); ++it){
for(face=0; face<4; ++face){
for(it = m.elements.begin(); it != m.elements.end(); ++it){
for(face = 0; face < 4; ++face){
if(it->b[face] < 0){
a = 0;
for(i=0; i<3; ++i){
for(i = 0; i < 3; ++i){
if(i == face) ++a;
face_el.v[i] = it->v[a++];
}
......
......@@ -23,12 +23,12 @@ double setup_time;
int verbosity = 2;
int progress_units = 0;
int output_precision = 10;
#if USE_COMPRESSION != 0
uint32_t use_compression = compression_bzip2;
uint32_t vtu_writer_mode = vtu_appended | vtu_compressed;
#else
#ifdef NO_COMPRESSION
uint32_t use_compression = compression_none;
uint32_t vtu_writer_mode = vtu_appended;
#else
uint32_t use_compression = compression_bzip2;
uint32_t vtu_writer_mode = vtu_appended | vtu_compressed;
#endif
uint32_t vtk_writer_mode = vtk_binary;
uint32_t arh_type = arh3;
......@@ -672,8 +672,8 @@ void call_curvature_vector(vector<string> &args, bool test){
}
}
//----------------------------------------< call_decimate_by_angle >
void call_decimate_by_angle(vector<string> &args, bool test){
//----------------------------------------< call_decimate_angle >
void call_decimate_angle(vector<string> &args, bool test){
string task_description = "decimating mesh";
int prompt_length = task_description.size() + 5;
......@@ -687,9 +687,9 @@ void call_decimate_by_angle(vector<string> &args, bool test){
double feature_angle = dval(args[1]);
if(m->dim_of_world != 2 || m->dim_of_elements != 1){
error("decimate_by_angle is currently only implemented for 2D-surfaces.");
error("decimate_angle is currently only implemented for 2D-surfaces.");
}else{
decimate_by_angle_2d(*m, feature_angle);
decimate_angle_2d(*m, feature_angle);
}
if(verbosity >= 1) cout << "ok" << endl;
......@@ -698,8 +698,8 @@ void call_decimate_by_angle(vector<string> &args, bool test){
}
}
//----------------------------------------< call_decimate_by_edge_length >
void call_decimate_by_edge_length(vector<string> &args, bool test){
//----------------------------------------< call_decimate_edge_length >
void call_decimate_edge_length(vector<string> &args, bool test){
string task_description = "decimating mesh";
int prompt_length = task_description.size() + 5;
......@@ -745,8 +745,8 @@ void call_decimate_by_edge_length(vector<string> &args, bool test){
}
}
//----------------------------------------< call_decimate_by_inner_angle >
void call_decimate_by_inner_angle(vector<string> &args, bool test){
//----------------------------------------< call_decimate_inner_angle >
void call_decimate_inner_angle(vector<string> &args, bool test){
string task_description = "decimating mesh";
int prompt_length = task_description.size() + 5;
......@@ -779,7 +779,7 @@ void call_decimate_by_inner_angle(vector<string> &args, bool test){
decimate_3d(*m, 0.0, INT_MAX, max_inner_angle, max_feature_angle, min_feature_net_size,
vecs, el_vecs);
}else{
error("decimate_by_inner_angle is only implemented for triangular meshes.");
error("decimate_inner_angle is only implemented for triangular meshes.");
}
if(verbosity >= 1) cout << "ok" << endl;
......@@ -788,8 +788,8 @@ void call_decimate_by_inner_angle(vector<string> &args, bool test){
}
}
//----------------------------------------< call_decimate_to_target_size >
void call_decimate_to_target_size(vector<string> &args, bool test){
//----------------------------------------< call_decimate_element_count >
void call_decimate_element_count(vector<string> &args, bool test){
string task_description = "decimating mesh";
int prompt_length = task_description.size() + 5;
......@@ -1264,6 +1264,39 @@ void call_duplicate_random_vertices(vector<string> &args, bool test){
}
}
//----------------------------------------< call_eliminate_flat_triangles >
void call_eliminate_flat_triangles(vector<string> &args, bool test){
string task_description = "eliminating degenerate triangles";
int prompt_length = task_description.size() + 5;
if(!test){
if(verbosity >= 1){
cout << task_description + fill_dots(prompt_length, task_description_length) << flush;
}
if(undefined_variable_warning != "") cout << undefined_variable_warning << flush;
check_argument_count_at_least(args, 1);
Mesh *m = lookup_mesh(args[0]);
if(m->dim_of_elements != 2) error("Input has to be a triangular mesh.");
double angle_threshold = 0.1;
int vec_stop = args.size() - 1;
if(args.size() > 1){
char last_first = args[args.size() - 1][0];
if(last_first >= '0' && last_first <= '9'){
--vec_stop;
angle_threshold = dval(args[args.size() - 1]);
}
}
vector<DataVector*> vecs;
for(int i = 1; i <= vec_stop; ++i) vecs.push_back(lookup_vector(args[i]));
eliminate_flat_triangles(*m, vecs, angle_threshold);
if(verbosity >= 1) cout << "ok" << endl;
}else{
if(task_description_length < prompt_length) task_description_length = prompt_length;
}
}
//----------------------------------------< call_end >
void call_end(vector<string> &args, string &cmdline, bool test){
vector<string> cmdargs;
......@@ -1338,6 +1371,27 @@ void call_ensure_edge_length(vector<string> &args, bool test){
}
}
//----------------------------------------< call_equalize_face_orientations >
void call_equalize_face_orientations(vector<string> &args, bool test){
string task_description = "equalizing face orientations";
int prompt_length = task_description.size() + 5;
if(!test){
if(verbosity >= 1){
cout << task_description + fill_dots(prompt_length, task_description_length) << flush;
}
if(undefined_variable_warning != "") cout << undefined_variable_warning << flush;
check_argument_count(args, 1);
Mesh *m = lookup_mesh(args[0]);
equalize_face_orientations(*m);
if(verbosity >= 1) cout << "ok" << endl;
}else{
if(task_description_length < prompt_length) task_description_length = prompt_length;
}
}
//----------------------------------------< call_extract_base_mesh >
void call_extract_base_mesh(vector<string> &args, bool test){
Mesh *m, *n;
......@@ -1779,8 +1833,8 @@ void call_fix_triangular_holes(vector<string> &args, bool test){
//----------------------------------------< call_for >
void call_for(vector<string> &args, string &cmdline, bool test){
vector<string> cmdargs;
unsigned long i;
long e, pos_p[5], psize;
uint64_t i;
int64_t e, pos_p[5], psize;
string task_description = "for";
int prompt_length = task_description.size() + 5;
......@@ -1951,6 +2005,27 @@ void call_invert_axis(vector<string> &args, bool test){
}
}
//----------------------------------------< call_invert_face_orientations >
void call_invert_face_orientations(vector<string> &args, bool test){
string task_description = "inverting face orientations";
int prompt_length = task_description.size() + 5;
if(!test){
if(verbosity >= 1){
cout << task_description + fill_dots(prompt_length, task_description_length) << flush;
}
if(undefined_variable_warning != "") cout << undefined_variable_warning << flush;
check_argument_count(args, 1);
Mesh *m = lookup_mesh(args[0]);
invert_face_orientations(*m);
if(verbosity >= 1) cout << "ok" << endl;
}else{
if(task_description_length < prompt_length) task_description_length = prompt_length;
}
}
//----------------------------------------< call_leole >
void call_leole(vector<string> &args, bool test){
int i;
......@@ -2334,7 +2409,7 @@ void call_partition(vector<string> &args, bool test){
string value_type = "";
for(unsigned i = 1; i < args.size(); ++i){
DataVector *vec = lookup_vector(args[i]);
if(value_type == "") value_type == vec->value_type;
if(value_type == "") value_type = vec->value_type;
else if(value_type != vec->value_type) error("Data-vectors have differing value-types.");
vv.push_back(pair<string, DataVector*>("", vec));
}
......@@ -3202,15 +3277,13 @@ void call_set_output_compression(vector<string> &args, bool test){
check_argument_count(args, 1);
use_compression = ival(args[0]);
#if USE_COMPRESSION == 0
#ifdef NO_COMPRESSION
if(use_compression != 0){
error("meshconv was not compiled with compression-support!"
+ string(" Try compilation without -DUSE_COMPRESSION=0."));
" Try compilation without -DNO_COMPRESSION.");
}
#endif
if(use_compression < 0 || use_compression > 2){
error("Unknown compression-type.");
}
if(use_compression > 2) error("Unknown compression-type.");
}
}
......@@ -3480,6 +3553,58 @@ void call_signdist_transformation_wrapper(vector<string> &args, bool test, strin
}
}
//----------------------------------------< call_split_edges_element_count >
void call_split_edges_element_count(vector<string> &args, bool test){
string task_description = "splitting edges";
int prompt_length = task_description.size() + 5;
if(!test){
if(verbosity >= 1){
cout << task_description + fill_dots(prompt_length, task_description_length) << flush;
}
if(undefined_variable_warning != "") cout << undefined_variable_warning << flush;
check_argument_count(args, 2);
Mesh *m = lookup_mesh(args[0]);
int min_element_count = ival(args[1]);
if((m->dim_of_world == 3 || m->dim_of_world == 2) && m->dim_of_elements == 2){
split_edges_3d(*m, -1.0, min_element_count);
}else{
error("Invalid dimensionality of input mesh.");
}
if(verbosity >= 1) cout << "ok" << endl;
}else{
if(task_description_length < prompt_length) task_description_length = prompt_length;
}
}
//----------------------------------------< call_split_edges_max_length >
void call_split_edges_max_length(vector<string> &args, bool test){
string task_description = "splitting edges";
int prompt_length = task_description.size() + 5;
if(!test){
if(verbosity >= 1){
cout << task_description + fill_dots(prompt_length, task_description_length) << flush;
}
if(undefined_variable_warning != "") cout << undefined_variable_warning << flush;
check_argument_count(args, 2);
Mesh *m = lookup_mesh(args[0]);
double max_edge_length = dval(args[1]);
if((m->dim_of_world == 3 || m->dim_of_world == 2) && m->dim_of_elements == 2){
split_edges_3d(*m, max_edge_length, INT_MAX);
}else{
error("Invalid dimensionality of input mesh.");
}
if(verbosity >= 1) cout << "ok" << endl;
}else{
if(task_description_length < prompt_length) task_description_length = prompt_length;
}
}
//----------------------------------------< call_subdivide >
void call_subdivide(vector<string> &args, bool test){
string task_description = "subdividing mesh";
......@@ -4348,10 +4473,10 @@ void call_vtu_type(vector<string> &args, bool test){
check_argument_count(args, 1);
vtu_writer_mode = ival(args[0]);
#if USE_COMPRESSION == 0
#ifdef NO_COMPRESSION
if(vtu_writer_mode & vtu_compressed){
error("meshconv was not compiled with compression-support!"
+ string(" Try compilation without -DUSE_COMPRESSION=0."));
" Try compilation without -DNO_COMPRESSION.");
}
#endif
if(vtu_writer_mode != vtu_ascii && vtu_writer_mode != vtu_appended
......@@ -4379,7 +4504,7 @@ void call_write(vector<string> &args, bool test){
suffix = file_suffix(args[0]);
if(suffix == "") error("Cannot determine type of file.");
flen = file_name(args[0]).size();
if(suffix=="per") flen += 3;
if(suffix == "per") flen += 3;
string task_description = "writing \"" + file_name(args[0]) + "\"";
int prompt_length = task_description.size() + 5;
......@@ -4857,11 +4982,11 @@ void execute_next_command(string &cmdline, bool test){
else if(srcmd == "cubelamp_function") call_vector_transformation_wrapper(cmdargs,
test, "calculating cubelamp_function", cubelamp_function, dm_mandatory); //undocumented
else if(srcmd == "curvature_vector") call_curvature_vector(cmdargs, test);
else if(srcmd == "decimate") call_decimate_to_target_size(cmdargs, test);
else if(srcmd == "decimate_by_angle") call_decimate_by_angle(cmdargs, test);
else if(srcmd == "decimate_by_edge_length") call_decimate_by_edge_length(cmdargs, test);
else if(srcmd == "decimate_by_inner_angle") call_decimate_by_inner_angle(cmdargs, test);
else if(srcmd == "decimate_to_target_size") call_decimate_to_target_size(cmdargs, test);
else if(srcmd == "decimate") call_decimate_element_count(cmdargs, test);
else if(srcmd == "decimate_angle") call_decimate_angle(cmdargs, test);
else if(srcmd == "decimate_edge_length") call_decimate_edge_length(cmdargs, test);
else if(srcmd == "decimate_inner_angle") call_decimate_inner_angle(cmdargs, test);
else if(srcmd == "decimate_element_count") call_decimate_element_count(cmdargs, test);
else if(srcmd == "declare_element_type") call_declare_element_type(cmdargs, test);
else if(srcmd == "delete_box_faces") call_delete_box_faces(cmdargs, test);
else if(srcmd == "delete_degenerate_elements") call_delete_degenerate_elements(cmdargs, test);
......@@ -4877,12 +5002,14 @@ void execute_next_command(string &cmdline, bool test){
else if(srcmd == "detect_holes") call_detect_holes(cmdargs, test);
else if(srcmd == "distance_repair") call_distance_repair(cmdargs, test);
else if(srcmd == "duplicate_random_elements")
call_duplicate_random_elements(cmdargs, test);
call_duplicate_random_elements(cmdargs, test);
else if(srcmd == "duplicate_random_vertices")
call_duplicate_random_vertices(cmdargs, test);
call_duplicate_random_vertices(cmdargs, test);
else if(srcmd == "eliminate_flat_triangles") call_eliminate_flat_triangles(cmdargs, test);
else if(srcmd == "end") call_end(cmdargs, cmdline, test);
else if(srcmd == "enforce_perfect_corners") call_enforce_perfect_corners(cmdargs, test);
else if(srcmd == "ensure_edge_length") call_ensure_edge_length(cmdargs, test);
else if(srcmd == "equalize_face_orientations") call_equalize_face_orientations(cmdargs, test);
else if(srcmd == "extract_base_mesh") call_extract_base_mesh(cmdargs, test);
else if(srcmd == "extract_surface") call_extract_surface(cmdargs, test);
else if(srcmd == "extract_vector_component") call_extract_vector_component(cmdargs, test);
......@@ -4902,6 +5029,7 @@ void execute_next_command(string &cmdline, bool test){
else if(srcmd == "if") call_if(cmdargs, test);
else if(srcmd == "interpolate_vector") call_interpolate_vector(cmdargs, test);
else if(srcmd == "invert_axis") call_invert_axis(cmdargs, test);
else if(srcmd == "invert_face_orientations") call_invert_face_orientations(cmdargs, test);
else if(srcmd == "leole") call_leole(cmdargs, test);
else if(srcmd == "levelset") call_levelset(cmdargs, test); //unfinished
else if(srcmd == "macro_refine") call_macro_refine(cmdargs, test);
......@@ -4957,6 +5085,9 @@ void execute_next_command(string &cmdline, bool test){
test, "signed distances to inverted-phasefield", signdist_to_inverted_phi);
else if(srcmd == "signdist_to_phi") call_signdist_transformation_wrapper(cmdargs,
test, "signed distances to phasefield", signdist_to_phi);
else if(srcmd == "split_edges") call_split_edges_element_count(cmdargs, test);
else if(srcmd == "split_edges_element_count") call_split_edges_element_count(cmdargs, test);
else if(srcmd == "split_edges_max_length") call_split_edges_max_length(cmdargs, test);
else if(srcmd == "start_timer") call_timer(cmdargs, test, 0);
else if(srcmd == "subdivide") call_subdivide(cmdargs, test);
else if(srcmd == "substring") call_substring(cmdargs, test);
......
......@@ -3,11 +3,7 @@
// Author: Florian Stenger
// This file is part of meshconv. See also license.txt in the distribution-folder.
#ifndef USE_COMPRESSION
#define USE_COMPRESSION 1
#endif
#if USE_COMPRESSION != 0
#ifndef NO_COMPRESSION
#include <sstream>
#include <fstream>
#include <boost/iostreams/device/array.hpp>
......@@ -133,4 +129,4 @@ void read_compressed_string(ifstream &in, string &str, const int compression_typ
}
} //end namespace meshconv
#endif //#if USE_COMPRESSION != 0
#endif //#ifndef NO_COMPRESSION
......@@ -345,7 +345,7 @@ struct VtuValueDecompressor : public VtuValueReader{
}
virtual void get_next_block(){//$ACL_exclude
#if USE_COMPRESSION != 0
#ifndef NO_COMPRESSION
if(++block_index == block_cnt - 1){
read_compressed_buffer(*in, cbuf, last_block_size, block_sizes_compressed[block_cnt - 1], 1);
}else{
......@@ -353,7 +353,8 @@ struct VtuValueDecompressor : public VtuValueReader{
}
byte_position = 0;
#else
error("meshconv was not compiled with compression-support!");
error("meshconv was not compiled with compression-support!"
" Try compilation without -DNO_COMPRESSION.");
#endif
}
};
......@@ -3036,7 +3037,7 @@ void read_arh3_file(string file, Mesh &m, vector<DataVector*> &vecs, bool has_ba
if(compression == compression_none){
in.read(buffer, base_element_body_sizes_uncompressed[i]);
}else if(compression == compression_zlib || compression == compression_bzip2){
#if USE_COMPRESSION != 0
#ifndef NO_COMPRESSION
unsigned compressed_size = base_element_body_positions[i + 1]
- base_element_body_positions[i];
read_compressed_buffer(in, buffer, base_element_body_sizes_uncompressed[i],
......@@ -3044,7 +3045,7 @@ void read_arh3_file(string file, Mesh &m, vector<DataVector*> &vecs, bool has_ba
#else
in.close();
error("meshconv was not compiled with compression-support!"
+ string(" Try compilation without -DUSE_COMPRESSION=0."));
" Try compilation without -DNO_COMPRESSION.");
return;
#endif
}else{
......
......@@ -578,12 +578,13 @@ struct VtuValueCompressor : public VtuValueWriter{
}
virtual void flush_block(){//$ACL_exclude
#if USE_COMPRESSION != 0
#ifndef NO_COMPRESSION
block_sizes_compressed[block_index++] = write_compressed_buffer(*out, cbuf, byte_position,
compression_zlib);
byte_position = 0;
#else
error("meshconv was not compiled with compression-support!");
error("meshconv was not compiled with compression-support!"
" Try compilation without -DNO_COMPRESSION.");
#endif
}
......@@ -2825,7 +2826,7 @@ void write_arh3_file(string file, Mesh &m, const vector<DataVector*> &vecs, stri
//compress (if desired) and write to file
if(use_compression == compression_zlib || use_compression == compression_bzip2){
#if USE_COMPRESSION != 0
#ifndef NO_COMPRESSION
base_element_body_sizes_compressed[i] =
write_compressed_buffer(out, buffer, base_element_body_sizes_uncompressed[i],
use_compression);
......
......@@ -384,7 +384,7 @@ void delete_mesh_partitioning(string name, bool erase_object, bool erase_temp_fi
}
}
if(erase_partitions){
unsigned numsize = ft(mp->partitions.size() - 1).size();
unsigned numsize = ft((uint64_t)mp->partitions.size() - 1).size();
for(unsigned p = 0; p < mp->partitions.size(); ++p){
delete_mesh(name + "$" + ft(p, numsize), true, true);
}
......@@ -900,24 +900,24 @@ void delete_all(){
//----------------------------------------< dbl_time >
//wallclock-time in seconds
double dbl_time(){
#if USE_CLOCK_GETTIME != 0
#ifdef NO_CLOCK_GETTIME
return (double)time(NULL);
#else
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
return (double)now.tv_nsec / 1000000000.0 + now.tv_sec;
#else
return (double)time(NULL);
#endif
}
//----------------------------------------< cpu_time >
//cpu-time of current thread in seconds
double cpu_time(){
#if USE_CLOCK_GETTIME != 0
#ifdef NO_CLOCK_GETTIME
return (double)clock() / CLOCKS_PER_SEC;
#else
struct timespec now;
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &now);
return (double)now.tv_nsec / 1000000000.0 + now.tv_sec;
#else
return (double)clock() / CLOCKS_PER_SEC;
#endif
}
......
This diff is collapsed.
......@@ -12,8 +12,8 @@
// - PROCESS_MEM_USAGE
// - ARH1_SUPPORT
// - NO_ATOMIC
// - USE_CLOCK_GETTIME=0
// - USE_COMPRESSION=0
// - NO_CLOCK_GETTIME
// - NO_COMPRESSION
#ifndef MESHCONV
#define MESHCONV
......@@ -40,14 +40,8 @@
namespace meshconv{
using namespace std;
#define MESHCONV_VERSION "v3.09"
#define MESHCONV_VERSION "v3.10"
#ifndef USE_CLOCK_GETTIME
#define USE_CLOCK_GETTIME 1
#endif
#ifndef USE_COMPRESSION