Loading...
Searching...
No Matches
DGF.cpp
1/*---------------------------------------------------------------------------*\
2 *
3 * bitpit
4 *
5 * Copyright (C) 2015-2021 OPTIMAD engineering Srl
6 *
7 * -------------------------------------------------------------------------
8 * License
9 * This file is part of bitpit.
10 *
11 * bitpit is free software: you can redistribute it and/or modify it
12 * under the terms of the GNU Lesser General Public License v3 (LGPL)
13 * as published by the Free Software Foundation.
14 *
15 * bitpit is distributed in the hope that it will be useful, but WITHOUT
16 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
18 * License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with bitpit. If not, see <http://www.gnu.org/licenses/>.
22 *
23\*---------------------------------------------------------------------------*/
24
25// ========================================================================== //
26// DGF IO FUNCTIONS //
27// //
28// I/O functions for .dgf file formats //
29// ========================================================================== //
30// INTFO //
31// ========================================================================== //
32// Author : Alessandro Alaia //
33// Version : v3.0 //
34// //
35// All rights reserved. //
36// ========================================================================== //
37
38// ========================================================================== //
39// INCLUDES //
40// ========================================================================== //
41
42# include "DGF.hpp"
43
44// ========================================================================== //
45// IMPLEMENTATIONS //
46// ========================================================================== //
47using namespace std;
48
49namespace bitpit{
50
60// class DGFObj methods ==================================================== //
61
62// Constructors ------------------------------------------------------------- //
63
64// -------------------------------------------------------------------------- //
70DGFObj::DGFObj(
71 void
72) {
73
74// ========================================================================== //
75// VARIABLES DECLARATION //
76// ========================================================================== //
77
78// Local variables
79// none
80
81// Counters
82// none
83
84// ========================================================================== //
85// SET MEMBERS TO DEFAULT VALUE //
86// ========================================================================== //
87
88// General info
89dgf_name = "";
90
91// Error flags
92err = 0;
93
94// dgf content
95data.nV = -1;
96data.nS = -1;
97
98
99return; }
100
101// -------------------------------------------------------------------------- //
109DGFObj::DGFObj(
110 const std::string &filename
111) {
112
113// ========================================================================== //
114// VARIABLES DECLARATION //
115// ========================================================================== //
116
117// Local variables
118// none
119
120// Counters
121// none
122
123// ========================================================================== //
124// SET MEMBERS TO DEFAULT VALUE //
125// ========================================================================== //
126
127// General info
128dgf_name = filename;
129dgf_name = utils::string::trim(dgf_name);
130
131// Error flags
132err = 0;
133
134// dgf content
135data.nV = -1;
136data.nS = -1;
137
138return; }
139
140// Destructors -------------------------------------------------------------- //
141// none
142
143// Public methods ----------------------------------------------------------- //
144
145// -------------------------------------------------------------------------- //
151void DGFObj::open(
152 const std::string &mode
153) {
154
155// ========================================================================== //
156// VARIABLES DECLARATION //
157// ========================================================================== //
158
159// Local variables
160// none
161
162// Counters
163// none
164
165// ========================================================================== //
166// OPEN STREAM //
167// ========================================================================== //
168if (mode.compare("in") == 0) {
169 if (!ifile_handle.is_open()) {
170
171 // Close open output stream
172 close("out");
173
174 // Open input stream
175 ifile_handle.open(dgf_name, ifstream::in | ifstream::binary);
176 if (!ifile_handle.good()) { err = 1; }
177
178 }
179}
180else if (mode.compare("out") == 0) {
181 if (!ofile_handle.is_open()) {
182
183 // Close open input stream
184 close("in");
185
186 // Open output stream
187 ofile_handle.open(dgf_name, ifstream::out);
188 if (!ofile_handle.good()) { err = 1; }
189
190 }
191}
192else if (mode.compare("app") == 0) {
193 if (!ofile_handle.is_open()) {
194
195 // Close open input stream
196 close("in");
197
198 // Open output stream in "append" mode
199 ofile_handle.open(dgf_name, ifstream::out | ifstream::app);
200 if (!ofile_handle.good()) { err = 1; }
201
202 }
203}
204
205return; };
206
207// -------------------------------------------------------------------------- //
214void DGFObj::close(
215 const std::string &mode
216) {
217
218// ========================================================================== //
219// VARIABLES DECLARATION //
220// ========================================================================== //
221
222// Local variables
223// none
224
225// Counters
226// none
227
228// ========================================================================== //
229// CLOSE STREAM //
230// ========================================================================== //
231if (mode.compare("in") == 0) {
232 if (ifile_handle.is_open()) {
233 ifile_handle.close();
234 }
235}
236else if (mode.compare("out") == 0) {
237 if (ofile_handle.is_open()) {
238 ofile_handle.close();
239 }
240}
241else if (mode.compare("app") == 0) {
242 if (ofile_handle.is_open()) {
243 ofile_handle.close();
244 }
245}
246else if (mode.compare("inout") == 0) {
247 if (ifile_handle.is_open()) {
248 ifile_handle.close();
249 }
250 if (ofile_handle.is_open()) {
251 ofile_handle.close();
252 }
253}
254
255
256
257return; };
258
259// -------------------------------------------------------------------------- //
263void DGFObj::clear(
264 void
265) {
266
267// ========================================================================== //
268// VARIABLES DECLARATION //
269// ========================================================================== //
270
271// Local variables
272// none
273
274// Counters
275// none
276
277// ========================================================================== //
278// RESET MEMBERS VALUES TO DEFAULT //
279// ========================================================================== //
280
281// Error flags
282err = 0;
283dgf_error.resize(0);
284
285// dgf content
286data.nV = -1;
287data.nS = -1;
288data.nV_data.resize(0);
289data.sV_data.resize(0);
290data.nS_data.resize(0);
291data.sS_data.resize(0);
292
293// Close open stream
294close("inout");
295
296return; };
297
298// -------------------------------------------------------------------------- //
304void DGFObj::display(
305 std::ostream &out
306) {
307
308// ========================================================================== //
309// void DGFObj::display( //
310// ostream &out) //
311// //
312// Display dgf content and infos. //
313// ========================================================================== //
314// INPUT //
315// ========================================================================== //
316// - out : ostream, output stream //
317// ========================================================================== //
318// OUTPUT //
319// ========================================================================== //
320// - none //
321// ========================================================================== //
322
323// ========================================================================== //
324// VARIABLES DECLARATION //
325// ========================================================================== //
326
327// Local variables
328// none
329
330// Counters
331int n, i;
332
333// ========================================================================== //
334// DISPLAY INFOS //
335// ========================================================================== //
336
337// General infos ------------------------------------------------------------ //
338out << "dgf object:" << endl;
339out << " dgf name : '" << dgf_name << "'" << endl;
340out << " input stream status : ";
341if (ifile_handle.is_open()) { out << "open"; }
342else { out << "closed"; }
343out << endl;
344out << " output stream status : ";
345if (ofile_handle.is_open()) { out << "open"; }
346else { out << "closed"; }
347out << endl;
348
349// Error status ------------------------------------------------------------- //
350if (err == 1) {
351 out << " **ERROR** dgf file is missing!!" << endl;
352}
353
354// Infos -------------------------------------------------------------------- //
355if (data.nV >= 0) {
356 out << " # of vertices : " << data.nV << endl;
357}
358if (data.nS >= 0) {
359 out << " # of simplicies : " << data.nS << endl;
360}
361if (data.nV_data.size() > 0) {
362 out << " vertex dataset names : " << data.sV_data << endl;
363 out << " # of vertex data : " << data.nV_data << endl;
364}
365if (data.nS_data.size() > 0) {
366 out << " simplex dataset names : " << data.sS_data << endl;
367 out << " # of simplex data : " << data.nS_data << endl;
368}
369
370// Error on data sets ------------------------------------------------------- //
371if (dgf_error.size() > 0) {
372
373 out << "ERROR report: " << endl;
374
375 // Vertex
376 out << " vertex: " << endl;
377 switch (dgf_error[0][0]) {
378 case 0: {out << " no errors" << endl; break; }
379 case 1: {out << " **WARNING** unterminated data block!!" << endl; break; }
380 case 2: {out << " **WARNING** missing data" << endl; break; }
381 };
382
383 // Simplex
384 out << " simplex: " << endl;
385 switch (dgf_error[1][0]) {
386 case 0: {out << " no errors" << endl; break; }
387 case 1: {out << " **WARNING** unterminated data block!!" << endl; break; }
388 case 2: {out << " **WARNING** missing data" << endl; break; }
389 };
390
391 // Vertex data sets
392 n = data.nV_data.size();
393 for (i = 0; i < n; i++) {
394 out << " vertex dataset '" << data.sV_data[i] << "': " << endl;
395 switch (dgf_error[2][i]) {
396 case 0: {out << " no errors" << endl; break; }
397 case 1: {out << " **WARNING** unterminated data block!!" << endl; break; }
398 case 2: {out << " **WARNING** missing data" << endl; break; }
399 };
400 } //next i
401
402 // Simplex data sets
403 n = data.nS_data.size();
404 for (i = 0; i < n; i++) {
405 out << " simplex dataset '" << data.sS_data[i] << "': " << endl;
406 switch (dgf_error[3][i]) {
407 case 0: {out << " no errors" << endl; break; }
408 case 1: {out << " **WARNING** unterminated data block!!" << endl; break; }
409 case 2: {out << " **WARNING** missing data" << endl; break; }
410 };
411 } //next i
412
413}
414
415return; }
416
417// -------------------------------------------------------------------------- //
421void DGFObj::scan(
422 void
423) {
424
425// ========================================================================== //
426// VARIABLES DECLARATION //
427// ========================================================================== //
428
429// Local variables
430// none
431
432// Counters
433// none
434
435// ========================================================================== //
436// OPEN INPUT STREAM //
437// ========================================================================== //
438open("in");
439
440// ========================================================================== //
441// SCAN DGF FILE //
442// ========================================================================== //
443err = dgf::scan(ifile_handle,
444 data.nV,
445 data.nS,
446 data.sV_data,
447 data.sS_data,
448 data.nV_data,
449 data.nS_data);
450
451// ========================================================================== //
452// CLOSE INPUT STREAM //
453// ========================================================================== //
454close("in");
455
456return; }
457
458// -------------------------------------------------------------------------- //
463void DGFObj::check(
464 void
465) {
466
467// ========================================================================== //
468// VARIABLES DECLARATION //
469// ========================================================================== //
470
471// Local variables
472// none
473
474// Counters
475// none
476
477// ========================================================================== //
478// SCAN DGF FILE //
479// ========================================================================== //
480scan();
481
482// ========================================================================== //
483// OPEN INPUT STREAM //
484// ========================================================================== //
485open("in");
486
487// ========================================================================== //
488// CHECK DATA COHERENCY //
489// ========================================================================== //
490err = dgf::check(ifile_handle, dgf_error);
491
492// ========================================================================== //
493// CLOSE INPUT STREAM //
494// ========================================================================== //
495close("in");
496
497return; }
498
499// -------------------------------------------------------------------------- //
516void DGFObj::load(
517 int &nV,
518 int &nS,
519 std::vector<std::vector<double> > &V,
520 std::vector<std::vector<int> > &S
521) {
522
523// ========================================================================== //
524// VARIABLES DECLARATION //
525// ========================================================================== //
526
527// Local variables
528// none
529
530// Counters
531// none
532
533// ========================================================================== //
534// OPEN INPUT STREAM //
535// ========================================================================== //
536open("in");
537
538// ========================================================================== //
539// READ MESH DATA FROM DGF FILE //
540// ========================================================================== //
541err = dgf::readMesh(ifile_handle, nV, nS, V, S);
542
543// ========================================================================== //
544// CLOSE INPUT STREAM //
545// ========================================================================== //
546close("in");
547
548return; };
549
550// -------------------------------------------------------------------------- //
568void DGFObj::load(
569 int &nV,
570 int &nS,
571 std::vector<std::array<double,3> > &V,
572 std::vector<std::vector<int> > &S
573) {
574
575// ========================================================================== //
576// VARIABLES DECLARATION //
577// ========================================================================== //
578
579// Local variables
580// none
581
582// Counters
583// none
584
585// ========================================================================== //
586// OPEN INPUT STREAM //
587// ========================================================================== //
588open("in");
589
590// ========================================================================== //
591// READ MESH DATA FROM DGF FILE //
592// ========================================================================== //
593err = dgf::readMesh(ifile_handle, nV, nS, V, S);
594
595// ========================================================================== //
596// CLOSE INPUT STREAM //
597// ========================================================================== //
598close("in");
599
600return; };
601
602// -------------------------------------------------------------------------- //
622void DGFObj::load(
623 int &nV,
624 int &nS,
625 std::vector<std::array<double,3> > &V,
626 std::vector<std::vector<int> > &S,
627 std::vector<int> &PID,
628 const std::string &pidName
629) {
630
631// ========================================================================== //
632// VARIABLES DECLARATION //
633// ========================================================================== //
634
635// Local variables
636// none
637
638// Counters
639// none
640
641// ========================================================================== //
642// OPEN INPUT STREAM //
643// ========================================================================== //
644open("in");
645
646// ========================================================================== //
647// READ MESH DATA FROM DGF FILE //
648// ========================================================================== //
649err = dgf::readMesh(ifile_handle, nV, nS, V, S);
650
651// ========================================================================== //
652// READ PID //
653// ========================================================================== //
654int nData = PID.size() ;
655err = dgf::readSimplexData(ifile_handle, nData, PID, pidName ) ;
656if (nData == (int) PID.size()) {
657 PID.resize(nS - nData, 0);
658}
659
660// ========================================================================== //
661// CLOSE INPUT STREAM //
662// ========================================================================== //
663close("in");
664
665return; };
666
667// -------------------------------------------------------------------------- //
676void DGFObj::save(
677 int &nV,
678 int &nS,
679 std::vector<std::vector<double> > &V,
680 std::vector<std::vector<int> > &S
681) {
682
683// ========================================================================== //
684// void DGFObj::save( //
685// int &nV, //
686// int &nS, //
687// dvector2D &V, //
688// ivector2D &S) //
689// //
690// SAve mesh data into a dgf file. //
691// ========================================================================== //
692// INPUT //
693// ========================================================================== //
694// - nV : int, number of mesh vertices //
695// - nS : int, number of simplicies //
696// - V : dvector2D, vertex coordinate list. V[i][0], V[i][1], ... //
697// are the x, y, ... coordinates of the i-th vertex //
698// - S : ivector2D, simplex-vertex connectivity S[i][0], S[i][1], //
699// ... are the global indices of vertices of the i-th simplex //
700// ========================================================================== //
701// OUTPUT //
702// ========================================================================== //
703// - none //
704// ========================================================================== //
705
706// ========================================================================== //
707// VARIABLES DECLARATION //
708// ========================================================================== //
709
710// Local variables
711// none
712
713// Counters
714// none
715
716// ========================================================================== //
717// OPEN OUTPUT STREAM //
718// ========================================================================== //
719open("out");
720
721// ========================================================================== //
722// READ MESH DATA FROM DGF FILE //
723// ========================================================================== //
724err = dgf::writeMesh(ofile_handle, nV, nS, V, S);
725
726// ========================================================================== //
727// CLOSE OUTPUT STREAM //
728// ========================================================================== //
729close("out");
730
731return; }
732
733// -------------------------------------------------------------------------- //
743void DGFObj::save(
744 int &nV,
745 int &nS,
746 std::vector<std::array<double,3> > &V,
747 std::vector<std::vector<int> > &S
748) {
749
750// ========================================================================== //
751// VARIABLES DECLARATION //
752// ========================================================================== //
753
754// Local variables
755// none
756
757// Counters
758// none
759
760// ========================================================================== //
761// OPEN OUTPUT STREAM //
762// ========================================================================== //
763open("out");
764
765// ========================================================================== //
766// READ MESH DATA FROM DGF FILE //
767// ========================================================================== //
768err = dgf::writeMesh(ofile_handle, nV, nS, V, S);
769
770// ========================================================================== //
771// CLOSE OUTPUT STREAM //
772// ========================================================================== //
773close("out");
774
775return; }
776
777// Private methods ---------------------------------------------------------- //
778
779// -------------------------------------------------------------------------- //
783void DGFObj::loadVData(
784 void
785) {
786
787// ========================================================================== //
788// VARIABLES DECLARATION //
789// ========================================================================== //
790
791// Local variables
792// none
793
794// Counters
795// none
796
797// ========================================================================== //
798// CLOSE INPUT STREAM //
799// ========================================================================== //
800close("in");
801
802return; }
803
804// -------------------------------------------------------------------------- //
808void DGFObj::loadSData(
809 void
810) {
811
812// ========================================================================== //
813// VARIABLES DECLARATION //
814// ========================================================================== //
815
816// Local variables
817// none
818
819// Counters
820// none
821
822// ========================================================================== //
823// CLOSE INPUT STREAM //
824// ========================================================================== //
825close("in");
826
827return; }
828
829// -------------------------------------------------------------------------- //
833void DGFObj::appendVData(
834 void
835) {
836
837// ========================================================================== //
838// VARIABLES DECLARATION //
839// ========================================================================== //
840
841// Local variables
842// none
843
844// Counters
845// none
846
847// ========================================================================== //
848// CLOSE OUTPUT STREAM //
849// ========================================================================== //
850close("app");
851
852return; }
853
854// -------------------------------------------------------------------------- //
858void DGFObj::appendSData(
859 void
860) {
861
862// ========================================================================== //
863// VARIABLES DECLARATION //
864// ========================================================================== //
865
866// Local variables
867// none
868
869// Counters
870// none
871
872// ========================================================================== //
873// CLOSE OUTPUT STREAM //
874// ========================================================================== //
875close("app");
876
877return; }
878
879// Scanning routines ======================================================== //
880
881// -------------------------------------------------------------------------- //
893unsigned int dgf::scanData(
894 std::ifstream &file_handle,
895 int &n
896) {
897
898// ========================================================================== //
899// VARIABLES DECLARATION //
900// ========================================================================== //
901
902// Local variables
903std::streamoff current_pos;
904std::string line, word;
905std::stringstream sline;
906
907// Counters
908// none
909
910// ========================================================================== //
911// CHECK STREAM STATUS //
912// ========================================================================== //
913if (!file_handle.good()) { return(1); }
914
915// ========================================================================== //
916// SCAN DATA SET //
917// ========================================================================== //
918
919// Get current line
920current_pos = file_handle.tellg();
921word = "begin";
922
923// Loop until end of data block
924while (!file_handle.eof()
925 && ((word.compare("#") != 0)
926 && (word.compare("VERTEX") != 0)
927 && (word.compare("SIMPLEX") != 0)
928 && (word.compare("VERTEXDATA") != 0)
929 && (word.compare("SIMPLEXDATA") != 0))) {
930
931 // Get next line
932 current_pos = file_handle.tellg();
933 getline(file_handle, line);
934 line = utils::string::trim(line);
935 sline.clear();
936 sline.str(line);
937
938 // Check if data exist
939 if (sline >> word) {
940 n++;
941 }
942
943} //next line
944if ((word.compare("#") == 0)
945 || (word.compare("VERTEX") == 0)
946 || (word.compare("SIMPLEX") == 0)
947 || (word.compare("VERTEXDATA") == 0)
948 || (word.compare("SIMPLEXDATA") == 0)){
949 file_handle.clear();
950 file_handle.seekg(current_pos);
951 n--;
952}
953
954return(0); }
955
956// -------------------------------------------------------------------------- //
972unsigned int dgf::scan(
973 std::ifstream &file_handle,
974 int &nV,
975 int &nS,
976 std::vector<std::string> &sV_data,
977 std::vector<std::string> &sS_data,
978 std::vector<int> &nV_data,
979 std::vector<int> &nS_data
980) {
981
982// ========================================================================== //
983// VARIABLES DECLARATION //
984// ========================================================================== //
985
986// Local variables
987unsigned int err = 0;
988std::streamoff start_pos;
989std::string line, word;
990std::stringstream sline;
991
992// Counters
993int n;
994
995// ========================================================================== //
996// CHECK STREAM STATUS //
997// ========================================================================== //
998if (!file_handle.good()) { return(1); }
999
1000// ========================================================================== //
1001// RESET INPUT DATA //
1002// ========================================================================== //
1003nV = 0;
1004nS = 0;
1005sV_data.resize(0);
1006sS_data.resize(0);
1007nV_data.resize(0);
1008nS_data.resize(0);
1009
1010// ========================================================================== //
1011// RESET CURSOR POSITION TO FILE BEGIN //
1012// ========================================================================== //
1013start_pos = file_handle.tellg();
1014file_handle.clear();
1015file_handle.seekg(0);
1016
1017// ========================================================================== //
1018// SCAN DGF FILE //
1019// ========================================================================== //
1020word = "begin";
1021while (!file_handle.eof()) {
1022
1023 // Get current line
1024 getline(file_handle, line);
1025 line = utils::string::trim(line);
1026 sline.clear();
1027 sline.str(line);
1028
1029 // Look for relevant keyword
1030 if (sline >> word) {
1031 if (word.compare("VERTEX") == 0) {
1032
1033 // Get number of vertices
1034 err = dgf::scanData(file_handle, nV);
1035 }
1036 else if (word.compare("SIMPLEX") == 0) {
1037
1038 // Get number of simplicies
1039 err = dgf::scanData(file_handle, nS);
1040 }
1041 else if (word.compare("VERTEXDATA") == 0) {
1042
1043 // Get data set name
1044 if (sline >> word) { sV_data.push_back(word); }
1045 else { sV_data.push_back(""); }
1046
1047 // Get number of data in the dataset
1048 n = 0;
1049 err = dgf::scanData(file_handle, n);
1050 nV_data.push_back(n);
1051 }
1052 else if (word.compare("SIMPLEXDATA") == 0) {
1053
1054 // Get data set name
1055 if (sline >> word) { sS_data.push_back(word); }
1056 else { sS_data.push_back(""); }
1057
1058 // Get number of data in the dataset
1059 n = 0;
1060 err = dgf::scanData(file_handle, n);
1061 nS_data.push_back(n);
1062 }
1063 }
1064} //next line
1065
1066// ========================================================================== //
1067// RESET CURSOR POSITION //
1068// ========================================================================== //
1069file_handle.clear();
1070file_handle.seekg(start_pos);
1071
1072return(err); }
1073
1074// Checking routines ======================================================== //
1075
1076// -------------------------------------------------------------------------- //
1090unsigned int dgf::checkData(
1091 std::ifstream &file_handle,
1092 int &err_code
1093) {
1094
1095// ========================================================================== //
1096// VARIABLES DECLARATION //
1097// ========================================================================== //
1098
1099// Local variables
1100std::streamoff current_pos;
1101std::string line, word;
1102std::stringstream sline;
1103
1104// Counters
1105// none
1106
1107// ========================================================================== //
1108// CHECK STREAM STATUS //
1109// ========================================================================== //
1110if (!file_handle.good()) { return(1); };
1111
1112// ========================================================================== //
1113// RESET INPUT VARIABLES //
1114// ========================================================================== //
1115err_code = 0;
1116
1117// ========================================================================== //
1118// CHECK DATA BLOCK //
1119// ========================================================================== //
1120word = "begin";
1121current_pos = file_handle.tellg();
1122while (!file_handle.eof()
1123 && ((word.compare("#") != 0)
1124 && (word.compare("VERTEX") != 0)
1125 && (word.compare("SIMPLEX") != 0)
1126 && (word.compare("VERTEXDATA") != 0)
1127 && (word.compare("SIMPLEXDATA") != 0))) {
1128
1129 // Get current line
1130 getline(file_handle, line);
1131 current_pos = file_handle.tellg();
1132 line = utils::string::trim(line);
1133 sline.clear();
1134 sline.str(line);
1135
1136 // Look for relevant keywords
1137 if (!(sline >> word)) {
1138 err_code = 2;
1139 }
1140} //next line
1141if (word.compare("#") != 0) {
1142 file_handle.clear();
1143 file_handle.seekg(current_pos);
1144 err_code = 1;
1145}
1146
1147return(0); }
1148
1149// -------------------------------------------------------------------------- //
1169unsigned int dgf::check(
1170 std::ifstream &file_handle,
1171 std::vector<std::vector<int> > &err_code
1172) {
1173
1174// ========================================================================== //
1175// VARIABLES DECLARATION //
1176// ========================================================================== //
1177
1178// Local variables
1179unsigned int err = 0;
1180std::streamoff start_pos;
1181int loc_err;
1182std::string line, word;
1183std::stringstream sline;
1184
1185// Counters
1186// none
1187
1188// ========================================================================== //
1189// CHECK INPUT STREAM //
1190// ========================================================================== //
1191if (!file_handle.good()) { return(1); }
1192
1193// ========================================================================== //
1194// RESET INPUT VARIABLES //
1195// ========================================================================== //
1196err_code.resize(4);
1197
1198// ========================================================================== //
1199// SET CURSOR POSITION AT FILE BEGIN //
1200// ========================================================================== //
1201file_handle.clear();
1202start_pos = file_handle.tellg();
1203file_handle.seekg(0);
1204
1205// ========================================================================== //
1206// SCAN DGF FILE //
1207// ========================================================================== //
1208word = "begin";
1209while ((!file_handle.eof()) && (word.compare("#") != 0)) {
1210
1211 // Get current line
1212 getline(file_handle, line);
1213 line = utils::string::trim(line);
1214 sline.clear();
1215 sline.str(line);
1216
1217 // Look for keywords
1218 if (sline >> word) {
1219 if (word.compare("VERTEX") == 0) {
1220 err_code[0].resize(1);
1221 err = dgf::checkData(file_handle, err_code[0][0]);
1222 }
1223 else if (word.compare("SIMPLEX") == 0) {
1224 err_code[1].resize(1);
1225 err = dgf::checkData(file_handle, err_code[1][0]);
1226 }
1227 else if (word.compare("VERTEXDATA") == 0) {
1228 err = dgf::checkData(file_handle, loc_err);
1229 err_code[2].push_back(loc_err);
1230 }
1231 else if (word.compare("SIMPLEXDATA") == 0) {
1232 err = dgf::checkData(file_handle, loc_err);
1233 err_code[3].push_back(loc_err);
1234 }
1235 }
1236} //next line
1237
1238// ========================================================================== //
1239// RESET CURSOR POSITION //
1240// ========================================================================== //
1241file_handle.clear();
1242file_handle.seekg(start_pos);
1243
1244return(err); }
1245
1246// Input functions ========================================================== //
1247
1248// -------------------------------------------------------------------------- //
1270unsigned int dgf::readMesh(
1271 std::ifstream &file_handle,
1272 int &nV,
1273 int &nS,
1274 std::vector<std::vector<double> > &V,
1275 std::vector<std::vector<int> > &S
1276) {
1277
1278// ========================================================================== //
1279// VARIABLES DECLARATION //
1280// ========================================================================== //
1281
1282// Local variables
1283unsigned int err = 0;
1284std::streamoff start_pos;
1285std::string line, word;
1286std::stringstream sline;
1287
1288// Counters
1289// none
1290
1291// ========================================================================== //
1292// CHECK STREAM STATUS //
1293// ========================================================================== //
1294if (!file_handle.good()) { return(1); }
1295
1296// ========================================================================== //
1297// SET CURSOR POSITION AT FILE BEGIN //
1298// ========================================================================== //
1299file_handle.clear();
1300start_pos = file_handle.tellg();
1301file_handle.seekg(0);
1302
1303// ========================================================================== //
1304// LOAD MESH DATA FROM FILE //
1305// ========================================================================== //
1306word = "begin";
1307while (!file_handle.eof()
1308 && (word.compare("#") != 0)) {
1309
1310 // Get current line
1311 getline(file_handle, line);
1312 line = utils::string::trim(line);
1313 sline.clear();
1314 sline.str(line);
1315
1316 // Look for keywords
1317 if (sline >> word) {
1318 if (word.compare("VERTEX") == 0) {
1319 err = readData(file_handle, nV, V);
1320 }
1321 else if (word.compare("SIMPLEX") == 0) {
1322 err = readData(file_handle, nS, S);
1323 }
1324 }
1325} //next line
1326
1327// ========================================================================== //
1328// RESET CURSOR POSITION //
1329// ========================================================================== //
1330file_handle.clear();
1331file_handle.seekg(start_pos);
1332
1333return(err); };
1334
1335// -------------------------------------------------------------------------- //
1358unsigned int dgf::readMesh(
1359 std::ifstream &file_handle,
1360 int &nV,
1361 int &nS,
1362 std::vector<std::array<double,3> > &V,
1363 std::vector<std::vector<int> > &S
1364) {
1365
1366// ========================================================================== //
1367// VARIABLES DECLARATION //
1368// ========================================================================== //
1369
1370// Local variables
1371unsigned int err = 0;
1372std::streamoff start_pos;
1373std::string line, word;
1374std::stringstream sline;
1375
1376// Counters
1377// none
1378
1379// ========================================================================== //
1380// CHECK STREAM STATUS //
1381// ========================================================================== //
1382if (!file_handle.good()) { return(1); }
1383
1384// ========================================================================== //
1385// SET CURSOR POSITION AT FILE BEGIN //
1386// ========================================================================== //
1387file_handle.clear();
1388start_pos = file_handle.tellg();
1389file_handle.seekg(0);
1390
1391// ========================================================================== //
1392// LOAD MESH DATA FROM FILE //
1393// ========================================================================== //
1394word = "begin";
1395while (!file_handle.eof()
1396 && (word.compare("#") != 0)) {
1397
1398 // Get current line
1399 getline(file_handle, line);
1400 line = utils::string::trim(line);
1401 sline.clear();
1402 sline.str(line);
1403
1404 // Look for keywords
1405 if (sline >> word) {
1406 if (word.compare("VERTEX") == 0) {
1407 err = dgf::readData(file_handle, nV, V);
1408 }
1409 else if (word.compare("SIMPLEX") == 0) {
1410 err = dgf::readData(file_handle, nS, S);
1411 }
1412 }
1413} //next line
1414
1415// ========================================================================== //
1416// RESET CURSOR POSITION //
1417// ========================================================================== //
1418file_handle.clear();
1419file_handle.seekg(start_pos);
1420
1421return(err); };
1422
1423// Output functions ========================================================= //
1424
1425// -------------------------------------------------------------------------- //
1439unsigned int dgf::writeMesh(
1440 std::ofstream &file_handle,
1441 int &nV,
1442 int &nS,
1443 std::vector<std::vector<double> > &V,
1444 std::vector<std::vector<int> > &S
1445) {
1446
1447// ========================================================================== //
1448// VARIABLES DECLARATION //
1449// ========================================================================== //
1450
1451// Local variables
1452unsigned int err = 0;
1453
1454// Counters
1455// none
1456
1457// ========================================================================== //
1458// CHECK STREAM STATUS //
1459// ========================================================================== //
1460if (!file_handle.good()) { return(1); }
1461
1462// ========================================================================== //
1463// EXPORT MESH DATA //
1464// ========================================================================== //
1465
1466// Vertex coordinate list
1467file_handle << "VERTEX" << endl;
1468err = dgf::writeData(file_handle, nV, V);
1469
1470// Simplex-vertex connectivity
1471file_handle << "SIMPLEX" << endl;
1472err = dgf::writeData(file_handle, nS, S);
1473
1474return(err); }
1475
1476// -------------------------------------------------------------------------- //
1491unsigned int dgf::writeMesh(
1492 std::ofstream &file_handle,
1493 int &nV,
1494 int &nS,
1495 std::vector<std::array<double,3> > &V,
1496 std::vector<std::vector<int> > &S
1497) {
1498
1499// ========================================================================== //
1500// VARIABLES DECLARATION //
1501// ========================================================================== //
1502
1503// Local variables
1504unsigned int err = 0;
1505
1506// Counters
1507// none
1508
1509// ========================================================================== //
1510// CHECK STREAM STATUS //
1511// ========================================================================== //
1512if (!file_handle.good()) { return(1); }
1513
1514// ========================================================================== //
1515// EXPORT MESH DATA //
1516// ========================================================================== //
1517
1518// Vertex coordinate list
1519file_handle << "VERTEX" << endl;
1520err = dgf::writeData(file_handle, nV, V);
1521
1522// Simplex-vertex connectivity
1523file_handle << "SIMPLEX" << endl;
1524err = dgf::writeData(file_handle, nS, S);
1525
1526return(err); }
1527
1528}
bitpit::DGFObj::err
unsigned int err
Definition DGF.hpp:85
bitpit::DGFObj::clear
void clear(void)
Definition DGF.cpp:263
bitpit::DGFObj::close
void close(const std::string &a="inout")
Definition DGF.cpp:214
bitpit::DGFObj::DGFObj
DGFObj(void)
Definition DGF.cpp:70
bitpit::DGFObj::save
void save(int &, int &, std::vector< std::vector< double > > &, std::vector< std::vector< int > > &)
Definition DGF.cpp:676
bitpit::DGFObj::open
void open(const std::string &)
Definition DGF.cpp:151
bitpit::DGFObj::check
void check(void)
Definition DGF.cpp:463
bitpit::DGFObj::display
void display(std::ostream &)
Definition DGF.cpp:304
bitpit::DGFObj::scan
void scan(void)
Definition DGF.cpp:421
bitpit::DGFObj::load
void load(int &, int &, std::vector< std::vector< double > > &, std::vector< std::vector< int > > &)
Definition DGF.cpp:516
bitpit::DGFObj::data
DGFData data
Definition DGF.hpp:86
bitpit::DGFObj::dgf_name
std::string dgf_name
Definition DGF.hpp:84
bitpit::utils::string::trim
std::string & trim(std::string &s)
Definition stringUtils.tpp:98
bitpit::dgf::scan
unsigned int scan(std::ifstream &, int &, int &, std::vector< std::string > &, std::vector< std::string > &, std::vector< int > &, std::vector< int > &)
Definition DGF.cpp:972
bitpit::dgf::writeMesh
unsigned int writeMesh(std::ofstream &, int &, int &, std::vector< std::vector< double > > &, std::vector< std::vector< int > > &)
Definition DGF.cpp:1439
bitpit::dgf::check
unsigned int check(std::ifstream &, std::vector< std::vector< int > > &)
Definition DGF.cpp:1169
bitpit::dgf::checkData
unsigned int checkData(std::ifstream &, int &)
Definition DGF.cpp:1090
bitpit::dgf::readMesh
unsigned int readMesh(std::ifstream &, int &, int &, std::vector< std::vector< double > > &, std::vector< std::vector< int > > &)
Definition DGF.cpp:1270
bitpit::dgf::scanData
unsigned int scanData(std::ifstream &, int &)
Definition DGF.cpp:893
bitpit::DGFData::sS_data
std::vector< std::string > sS_data
Definition DGF.hpp:75
bitpit::DGFData::sV_data
std::vector< std::string > sV_data
Definition DGF.hpp:73
bitpit::DGFData::nV_data
std::vector< int > nV_data
Definition DGF.hpp:72
bitpit::DGFData::nS_data
std::vector< int > nS_data
Definition DGF.hpp:74
--- layout: doxygen_footer ---
Generated on Wed Jun 19 2024 10:21:05 for bitpit by   doxygen 1.10.0