commit du bug rebelle

bubulles.c

@@ -122,15 +122,15 @@ int print_bublist_desc(BBList *bbl, int opts)
 {
 
 fprintf(stderr, "------- bblist at %p\n", bbl);
-fprintf(stderr, "\tname \t'%s'\n", bbl->name);
+fprintf(stderr, "\tname\t\t'%s'\n", bbl->name);
 
-fprintf(stderr, "\tsize\t%6d\n\tfidx\t%6d\n", bbl->size, bbl->fidx);
+fprintf(stderr, "\tsize/fidx\t%d  %d\n", bbl->size, bbl->fidx);
 if (opts & 0x01) {
-	fprintf(stderr, "\txyz\t%f %f %f\n",
+	fprintf(stderr, "\txyz\t\t%f %f %f\n",
 		bbl->position.x, bbl->position.y, bbl->position.z);
 	}
-fprintf(stderr, "\tflags\t0x%08lX\n", bbl->flags);
-fprintf(stderr, "\tarray\t%p\n", bbl->bbs);
+fprintf(stderr, "\tflags\t\t0x%08lX\n", bbl->flags);
+fprintf(stderr, "\tarray@\t\t%p\n", bbl->bbs);
 
 fflush(stderr);
 

bubulles.h

@@ -4,7 +4,7 @@
 
 /* --------------------------------------------------------------------- */
 
-#define LIBBB_VERSION		63
+#define LIBBB_VERSION		64
 
 #define SZ_BUBULLE_TEXT		81		/* arbitrary value */
 

edges.c

@@ -70,28 +70,36 @@ return 0;
  */
 static int is_edge_in_list(EdgeList *list, int p0, int p1)
 {
-int		idx;
+int		idx, retval, place;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p  %d %d )\n", __func__, list, p0, p1);
+#endif
+
+retval = 0;	place = -1;
 
 for (idx=0; idx < list->fidx; idx++) {
 	if (	(list->edges[idx].A == p0) &&
-		(list->edges[idx].B == p1) )		return 1;
+		(list->edges[idx].B == p1) ) {
+			retval = 1; place = idx; break; }
 
 	if (	(list->edges[idx].A == p1) &&
-		(list->edges[idx].B == p0) )		return 2;
+		(list->edges[idx].B == p0) ){
+			retval = 2; place = idx; break; }
 	}
 
-return 0;		/* NOT FOUND */
+if (retval) fprintf(stderr, "  edge %d %d found at %d\n", p0, p1, idx);
+
+return retval;
 }
 /* --------------------------------------------------------------------- */
 /*
- *
  *	we have two functions for adding an edge to a list
  *	the first one add unconditionnaly the edge to the
  *	(non full) list...
  */
 int push_an_edge(EdgeList *list, int p0, int p1)
 {
-
 #if DEBUG_LEVEL
 fprintf(stderr, ">>> %s ( %p  %d %d )\n", __func__, list, p0, p1);
 #endif
@@ -130,8 +138,12 @@ if (list->fidx >= list->size) {
 if ( ! is_edge_in_list(list, p0, p1) ) {
 	list->edges[list->fidx].A = p0;
 	list->edges[list->fidx].B = p1;
+	fprintf(stderr, "edge %d %d poked at %d\n", p0, p1, list->fidx);
 	list->fidx ++;
 	}
+else	{
+	fprintf(stderr, "    %s: drop edge %d %d\n", __func__, p0, p1);
+	}
 return 0;
 }
 /* --------------------------------------------------------------------- */

tbb.c

@@ -186,7 +186,8 @@ int main(int argc, char *argv[])
 {
 int		foo;
 
-fprintf(stderr, "*** Bubulles Testing  %s %s\n\n", __DATE__, __TIME__);
+fprintf(stderr, "***\n*** Bubulles Testing  %s %s\n***\n",
+				__DATE__, __TIME__);
 
 bubulles_version(0);
 
@@ -200,8 +201,9 @@ foo = test_peek_poke(5000);
 fprintf(stderr, "test peek/poke -> %d\n", foo);
 #endif
 
-// XXX foo = essai_des_edges_A(25);
-// XXX fprintf(stderr, "test A des edges -> %d\n", foo);
+
+foo = essai_des_edges_A(25);
+fprintf(stderr, "test A des edges -> %d\n", foo);
 foo = essai_des_edges_B(5000);
 fprintf(stderr, "test B des edges -> %d\n", foo);
 

tools/.gitignore

@@ -6,7 +6,9 @@ export_evblob
 *.obj
 ! tools/minimal.obj
 ! tools/cube.obj
+! overflowed.obj
 read_obj
+
 *.xyz
 *.asc
 toto

tools/Makefile

@@ -1,9 +1,9 @@
 
 BBFUNCS = ../libbubulles.a 
 
-OPT = -Wall -Wextra -g -DDEBUG_LEVEL=0 -DMUST_ABORT=0
+OPT = -Wall -Wextra -O1 -g -DDEBUG_LEVEL=0 -DMUST_ABORT=0
 
-all:	read_obj export_evblob essai_faces
+all:	read_obj export_evblob			# essai_faces
 
 # ---------
 

tools/README.md

@@ -1,4 +1,3 @@
-
 # Importer des fichiers .OBJ
 
 * https://en.wikipedia.org/wiki/Wavefront_.obj_file
@@ -20,9 +19,9 @@ en déduire les arètes (aka: edges).
 
 Et à partir de cette analyse, nous allons générer un fichier
 binaire contenant les points xyx, et les arêtes pointA-pointB.
-Le format de ce fichier doit être considéré //opaque//.
-il sera généré dans le $PWD avec le nom du fichier .OBJ mais
-avec l'extension .evblob.
+Le format de ce fichier doit être considéré *opaque*.
+il sera généré dans le $PWD en utilisant le basename du fichier .OBJ mais
+avec l'extension `.evblob`.
 
 Ce n'est qu'une première étape, d'autres formats de sortie
 pourront être implémentés.
@@ -37,16 +36,29 @@ Deuxième étape : À partir du fichier .evblob généré à l'étape
 précédente, nous allons créer (entre autres options ?)
 un fichier utilisable par Povray. La première option a été
 la génération des arêtes, nous aurons donc sur `stdout`
-six nombres réels: xyz(pointA) et xyz(pointB).
+six nombres réels: xyz(pointA) et xyz(pointB) :
 
-Et là, c'est trop facile, Unix le fait depuis quarante ans.
-Un petit [script Awk](./edges2cylinders.awk) fera l'affaire.
+```
+25.2275466 19.5029792 -25.1227169   35.6406135 19.5029792 0.0166420
+35.6406135 19.5029792 0.0166420   0.0881849 19.5029792 -35.5357818
+0.0881849 19.5029792 -35.5357818   25.2275466 19.5029792 -25.1227169
+```
+
+Et là, c'est trop facile pour la suite, Unix sait le faire depuis
+quarante ans.
+Un petit [script Awk](./edges2cylinders.awk) fera l'affaire,
+en toute simplicité.
+
+Bien entendu, la même chose pourrait être faire pour les vertices,
+ce qui nous remet dans la droite ligne orthodoxe des bubulles.
 
 ## TODO LIST
 
 * Songer à un système d'auto-scaler et de recentrage
 * Comment générer un `.obj` à partir d'une image flottante ?
 * Gérer les arêtes de longueur nulle (degenerated cylinder)
+* Que faire des vertices qui ne sont pas utilisées par des faces ?
+* Plonger un peu dans la [technique](./technique.md).
 
 ## rendu final
 

tools/edges2bubulles.awk

@@ -0,0 +1,24 @@
+#!/bin/awk -f
+
+#
+#	this software is NOT ready for prime time !
+#
+
+BEGIN	{
+	count = 0
+	print "/* DO NOT EDIT BY HAND, BASTARD !*/"
+	print "/* generated ", strftime(), "    */"
+	print
+	print "#declare OBJ_vertices = object\n{"
+	print "union {"
+	}
+
+	{
+	printf "sphere { <%.9f, %.9f, %.9f>, RR }\n", $1, $2, $3
+	count++;
+	}
+
+END	{
+	print " }\n}\n"
+	print "// ", count, "vertices.\n"
+	}

tools/essai_faces.c

@@ -32,6 +32,10 @@ printf(" ->  %d\n", bar);
 return 0;
 }
 
+/*
+ *		GO !
+ */
+
 int main(int argc, char *argv[])
 {
 int		foo, bar;

tools/export_evblob.c

@@ -19,20 +19,114 @@ int		verbosity;
 
 /* --------------------------------------------------------------------- */
 /*			EXPERIMENTAL GRUIK-CODE !!!			 */
-int load_and_printf_evblob(char *filename, int mode)
+int printf_the_boudingbox(EdgesAndVertices *eav)
 {
-EdgesAndVertices	eav;
-int			foo, idx, a, b;
+int		idx;
+double		x, y, z;
+double		minX, minY, minZ;
+double		maxX, maxY, maxZ;
+
+minX = minY = minZ =  1e35;
+maxX = maxY = maxZ = -1e35;
 
 #if DEBUG_LEVEL
-fprintf(stderr, ">>> %s ( '%s'  %d )\n", __func__, filename, mode);
+fprintf(stderr, ">>> %s ( %p )\n", __func__, eav);
 #endif
 
-if (mode) {
-	fprintf(stderr, "W: in %s 'mode' must be zero, and was %d\n",
-				__func__, 		mode);
+fprintf(stderr, "====== %s is not fully implemented ======\n", __func__);
+
+for (idx=0; idx<eav->Blist->fidx; idx++) {
+	x = eav->Blist->bbs[idx].p.x;
+	y = eav->Blist->bbs[idx].p.y;
+	z = eav->Blist->bbs[idx].p.z;
+
+	if	(x < minX)		minX = x;
+	else if (x > maxX)		maxX = x;
+	if	(y < minY)		minY = y;
+	else if (y > maxY)		maxY = y;
+	if	(z < minZ)		minZ = z;
+	else if (z > maxZ)		maxZ = z;
+
 	}
 
+printf(		"%.9f %.9f %.9f   %.9f %.9f %.9f\n",
+		minX, minY, minZ, maxX, maxY, maxZ);
+
+return -1;
+}
+/* --------------------------------------------------------------------- */
+/*			EXPERIMENTAL GRUIK-CODE !!!			 */
+int printf_the_vertices(EdgesAndVertices *eav)
+{
+int		idx;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p )\n", __func__, eav);
+#endif
+
+if (verbosity) fprintf(stderr, "fprinting %d vertices\n", eav->Blist->fidx);
+
+for (idx=0; idx<eav->Blist->fidx; idx++) {
+	printf("%.9f %.9f %.9f\n",
+		eav->Blist->bbs[idx].p.x,
+		eav->Blist->bbs[idx].p.y,
+		eav->Blist->bbs[idx].p.z	);
+	}
+
+return 0;
+}
+/* --------------------------------------------------------------------- */
+/*			EXPERIMENTAL GRUIK-CODE !!!			 */
+int printf_the_edges(EdgesAndVertices *eav)
+{
+int		idx, a, b, vmax;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p )\n", __func__, eav);
+#endif
+
+if (verbosity) fprintf(stderr, "    fprinting %d edges\n", eav->Elist->fidx);
+
+vmax = eav->Blist->fidx;
+fprintf(stderr, "    %s: eav->Blist->fidx = %d\n", __func__, vmax);
+
+/*
+ *	OK we have (maybe) all the data in da place
+ *	and we can spit all the edges to stdout
+ */
+for (idx=0; idx<eav->Elist->fidx; idx++) {
+
+	a = eav->Elist->edges[idx].A;
+	b = eav->Elist->edges[idx].B;
+
+	/* this is a Molly-Guard */
+	if ( (a<0) || (b<0) || (a>vmax) || (b>vmax) ) {
+		fprintf(stderr, "ERROR: vmax=%d a=%d b=%d\n", vmax, a, b);
+		continue;
+		}
+
+	printf("%.9f %.9f %.9f   %.9f %.9f %.9f\n",
+		eav->Blist->bbs[a].p.x,
+		eav->Blist->bbs[a].p.y,
+		eav->Blist->bbs[a].p.z,
+		eav->Blist->bbs[b].p.x,
+		eav->Blist->bbs[b].p.y,
+		eav->Blist->bbs[b].p.z	);
+	}
+
+return 0;		/* allway success ? */
+}
+/* --------------------------------------------------------------------- */
+/*			EXPERIMENTAL GRUIK-CODE !!!			 */
+int load_and_printf_evblob(char *filename, char *outmode)
+{
+EdgesAndVertices	eav;
+int			foo, mode;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( '%s'  %s )\n", __func__, filename, outmode);
+#endif
+
 memset(&eav, 0, sizeof(EdgesAndVertices));
 foo = x_load_vertedges(filename, &eav);
 if (foo) {
@@ -40,7 +134,7 @@ if (foo) {
 	return foo;
 	}
 
-if (verbosity) {
+if (verbosity > 1) {
 	fprintf(stderr, "vertices at   %p\n", eav.Blist);
 	fprintf(stderr, "edges at      %p\n", eav.Elist);
 	fprintf(stderr, "status is     %d\n", eav.status);
@@ -49,32 +143,45 @@ if (verbosity) {
 				eav.Elist->fidx);
 	}
 
-/*
- *	OK we have (maybe) all the data in da place
- *	and we can spit all the edges to stdout
- */
+mode = 666;
+if      (! strcasecmp("edges",    outmode)) { mode = 0; }
+else if (! strcasecmp("vertices", outmode)) { mode = 1; }
+else if (! strcasecmp("bbox",     outmode)) { mode = 2; }
 
-for (idx=0; idx<eav.Elist->fidx; idx++) {
+switch (mode) {
+	case 0:
+		foo = printf_the_edges(&eav);			break;
+	case 1:
+		foo = printf_the_vertices(&eav);		break;
+	case 2:
+		foo = printf_the_boudingbox(&eav);		break;
 
-	a = eav.Elist->edges[idx].A;
-	b = eav.Elist->edges[idx].B;
-	// fprintf(stderr, "%7d %7d\n", a, b);
-
-	printf("%.9f %.9f %.9f   %.9f %.9f %.9f\n", 
-		eav.Blist->bbs[a].p.x,
-		eav.Blist->bbs[a].p.y,
-		eav.Blist->bbs[a].p.z, 
-		eav.Blist->bbs[b].p.x,
-		eav.Blist->bbs[b].p.y,
-		eav.Blist->bbs[b].p.z	);
+	default:
+		fprintf(stderr, "%s: no way for '%s'\n", __func__, outmode);
+		exit(1);
+		break;
 	}
 
+if (foo) {
+	fprintf(stderr, "%s: action '%s' -> %d\n", __func__, outmode, foo);
+	exit(1);
+	}
+
+/* deallocate used memory for keep pinpin happy */
+free_bubulles(eav.Blist, 1);
+free_edgelist(eav.Elist, 1);
+
 return 0;
 }
 /* --------------------------------------------------------------------- */
 void help(void)
 {
-fprintf(stderr, "YOLO!\n");
+
+puts("usage:\n  $ export_evblob [opts] fichier.evblob");
+puts("\t-h\tsome short help...");
+puts("\t-t\tone of [edges vertices bbox]");
+puts("\t-v\tbe more verbose");
+
 exit(0);
 }
 /* --------------------------------------------------------------------- */
@@ -83,19 +190,25 @@ exit(0);
 int main(int argc, char *argv[])
 {
 int			opt, foo;
+char			*outmode = "vertices";
 
-fprintf(stderr, "### EdgesAndVertices  -  %s %s\n", __DATE__, __TIME__);
+fprintf(stderr, "### Export EVblob   (%s %s)\n", __DATE__, __TIME__);
 
 verbosity = 0;
 
-while ((opt = getopt(argc, argv, "hv")) != -1) {
+while ((opt = getopt(argc, argv, "ht:v")) != -1) {
 	switch(opt) {
 		case 'h':
 			help();			break;
 		case 'v':
 			verbosity++;		break;
+		case 't':
+			// fprintf(stderr, "type -> '%s'\n", optarg);
+			outmode = optarg;
+			break;
 		default:
-			fprintf(stderr, "gni(%c)?\n", opt);
+			fprintf(stderr, "'%c' EBADOPT\n", opt);
+			exit(1);
 			break;
 		}
 	}
@@ -106,7 +219,7 @@ fprintf(stderr, "optind=%d argc=%d\n", optind, argc);
 
 if (optind < argc) {
 	// fprintf(stderr, "ARG = %s\n", argv[optind]);
-	foo = load_and_printf_evblob(argv[optind], 0);
+	foo = load_and_printf_evblob(argv[optind], outmode);
 	if (foo) {
 		fprintf(stderr, "Error number %d on '%s'\n", foo, argv[optind]);
 		exit(1);

tools/importobj.c

@@ -22,6 +22,7 @@ extern int		verbosity;
 
 /* --------------------------------------------------------------------- */
 
+#define PSYCHOTIK		1
 #define LINE_SZ			666
 
 static	BBList			*bublist;
@@ -49,7 +50,7 @@ Tokens TokenList[] = {
 	{  "vn",	T_vt		},	// c'est quoi ce truc ?
 	{  "l",		T_line		},
 	{  "o",		T_object	},
-	{  "s",		T_smoothing 	},
+	{  "s",		T_smoothing 	},	// mmmm....
 	{  "usemtl",	T_usemtl	},
 	{  "mtllib",	T_mtllib	},
 	/*    and more to come...	*/
@@ -103,15 +104,14 @@ return foo;
 /* new Mon 27 Mar 2023 12:08:18 AM CEST
  *
  *	mmmm... complex thing to do...
- *	and what is this "phy" parameter ?
  */
-static int parse_face(char *cptr)
+static int parse_face(char *cptr, int maxvert)
 {
 int		ix, foo, a, b;
-int		pts[3];
+int		pts[3], valid;
 
 #if DEBUG_LEVEL
-fprintf(stderr, ">>> %s ( '%s' )\n", __func__, cptr, phy);
+fprintf(stderr, ">>> %s ( '%s'  %d )\n", __func__, cptr, maxvert);
 #endif
 
 #if (0)
@@ -135,34 +135,46 @@ for (ix=0; ix<3; ix++) {
 		}
 	}
 
-/** check the freshly read datas **/
+fprintf(stderr, "    %s:   pts %5d  %5d  %5d\n", __func__, 
+			pts[0], pts[1], pts[2]);
+
+valid = 1;
+
+/**** check the freshly read datas ****/
 if (  pts[0]==pts[1] || pts[0]==pts[2] || pts[2]==pts[1] ) {
 	fprintf(stderr, "%s: degenerated face ( %d %d %d )\n", __func__,
 				pts[0], pts[1], pts[2]);
 	dropped++;
+	valid = 0;
+	}
+if ( (pts[0]>maxvert) || (pts[1]>maxvert) || (pts[2]>maxvert) ) {
+	fprintf(stderr, "%s: out of bound ( %d %d %d )\n", __func__,
+				pts[0], pts[1], pts[2]);
+	valid = 0;
 	}
-
 /*
  *  may be we can check the "degenerated cylinder" here ?
  */
-
-for (ix=0; ix<3; ix++) {
-	a =  ix    % 3;
-	b = (ix+1) % 3;
-	foo = push_a_missing_edge(edges, pts[a], pts[b]);
-	if (foo) {
-		fprintf(stderr, "%s: disaster #%d line %d\n",
-				__func__, foo, linenumber);
-		return -2;
+if (valid)	{
+	for (ix=0; ix<3; ix++) {
+		a =  ix    % 3;
+		b = (ix+1) % 3;
+#if PSYCHOTIK
+		foo = push_a_missing_edge(edges, pts[a], pts[b]);
+#else
+		foo = push_an_edge(edges, pts[a], pts[b]);
+#endif
+		if (foo) {
+			fprintf(stderr, "%s: disaster #%d line %d\n",
+					__func__, foo, linenumber);
+			return -2;
+			}
 		}
 	}
 
-if (dropped) {
-	fprintf(stderr, "%s: %d dropped...\n", __func__, dropped);
-	// exit(1);
-	}
+if (dropped) fprintf(stderr, "%s: %d dropped\n", __func__, dropped);
 
-#if DEBUG_LEVEL
+#if DEBUG_LEVEL > 1
 fprintf(stderr, "<<< %s\n", __func__);
 #endif
 
@@ -170,20 +182,23 @@ return 0;
 }
 /* --------------------------------------------------------------------- */
 /*
- *
+ *    The main procedure, who contains a lot of things.
  */
-int try_to_read_an_OBJ_file(char *infname, int outstyle)
+int try_to_read_an_OBJ_file(char *infname, char *ofname, int outstyle)
 {
 FILE		*fpin;
 char		line[LINE_SZ+1], *cptr, *token;
 float		x, y, z;
-int		foo, tokenid;
+int		foo, bar, tokenid;
 Bubulle         bubulle;
-
 char		*outfname, *baseptr;
 
 #if DEBUG_LEVEL
-fprintf(stderr, ">>> %s ( '%s' ... %d )\n\n", __func__, infname, notused);
+fprintf(stderr, ">>> %s ( '%s'  '%s'  %d )\n", __func__,
+			infname, ofname, outstyle);
+#endif
+#if PSYCHOTIK
+fprintf(stderr, "    *** PSYCHOTIK MODE ENGAGED ***\n");
 #endif
 
 /* get memory for generated output filename(s) */
@@ -198,21 +213,21 @@ if (NULL==(fpin=fopen(infname, "r"))) {
 	}
 linenumber = 0;
 
-bublist = alloc_bubulles(infname, 600000, 0);
+bublist = alloc_bubulles(infname, 800000, 0);
 if (NULL==bublist) {
         fprintf(stderr, "in %s, no mem for bubls, aborting...\n", __func__);
         abort();
         }
 if (verbosity > 1)  print_bublist_desc(bublist, 0);
 
-edges = alloc_edgelist("krkrkr", 2200000, 0);
+edges = alloc_edgelist("krkrkr", 3000000, 0);
 if (NULL==edges) {
         fprintf(stderr, "no mem for edges in %s, aborting...\n", __func__);
         abort();
         }
 if (verbosity > 1)  print_edgelist_desc(edges, 0);
 
-fprintf(stderr, "\n  ***************************************\n");
+fprintf(stderr, "  +-----------------------------------------\n");
 
 while(NULL!=(cptr=fgets(line, LINE_SZ, fpin))) {
 
@@ -252,23 +267,29 @@ while(NULL!=(cptr=fgets(line, LINE_SZ, fpin))) {
 		case T_vertice:
 			x = y = z = 0.0;
 			foo = parse_vertice(cptr, &x, &y, &z);
-			if (3!=foo) {
+			if (3 != foo) {
+				fprintf(stderr, "err %d parse vertice %s\n",
+							foo, cptr);
 				abort();
 				}
 			bubulle.p.x = x;
 			bubulle.p.y = y;
 			bubulle.p.z = z;
-			if (verbosity > 1) niceprint_bubulle(&bubulle, 0);
+			if (verbosity > 2) niceprint_bubulle(&bubulle, 0);
 			foo = push_bubulle(bublist, &bubulle);
 			if (foo) {
+				fprintf(stderr, "err %d push bubulle\n", foo);
 				abort();
 				}
+			fprintf(stderr, "pushed %f %f %f (%d)\n", x, y, z,
+							bublist->fidx);
 			break;
 		case T_face:
 			/* experimental code here */
-			foo = parse_face(cptr);
+			bar = bublist->fidx - 1;
+			foo = parse_face(cptr, bar);
 			if (foo) {
-				 fprintf(stderr, "line %d  '%s' parse face -> %d\n",
+				 fprintf(stderr, "line %d '%s' parseface -> %d\n",
 							linenumber, cptr, foo);
 				exit(1);
 				}
@@ -292,25 +313,33 @@ while(NULL!=(cptr=fgets(line, LINE_SZ, fpin))) {
 			break;
 
 		case T_line:
+			cptr = strtok(NULL, " ");
+			fprintf(stderr, "\tLine:    %s\n", cptr);
 			break;
 		case T_smoothing:
+			cptr = strtok(NULL, " ");
+			if (verbosity)
+				fprintf(stderr, "\tSmoothing:    %s\n", cptr);
 			break;
 		case T_vt:
+			cptr = strtok(NULL, " ");
+			if (verbosity)
+				fprintf(stderr, "\tvt ??? :    %s\n", cptr);
 			break;
 			 
 		default:
-			fprintf(stderr, "token %s -> %d ?\n", token, tokenid);
+			fprintf(stderr, "W: token %s -> %d ?\n", token, tokenid);
 			break;
 		}
 	}
 
 fclose(fpin);
 
-fprintf(stderr, "  ***************************************\n");
+fprintf(stderr, "  +-----------------------------------------\n");
 
 if(verbosity) {
-	fprintf(stderr, "%s(): %d vertices loaded\n", __func__, bublist->fidx);
-	fprintf(stderr, "%s(): %d edges    loaded\n", __func__, edges->fidx);
+	fprintf(stderr, "%s: %d vertices and %d edges loaded.\n", __func__,
+				bublist->fidx, edges->fidx);
 	}
 
 if (verbosity > 1) {
@@ -318,7 +347,7 @@ if (verbosity > 1) {
 	print_edgelist_desc(edges, 0);
 	}
 
-if (outstyle) {		/* two ascii files */
+if (outstyle) {					/* two ascii files */
 	strcpy(outfname, infname);
 	cptr = rindex(outfname, '.');
 	fprintf(stderr, "rindex -> [%s]\n", cptr);
@@ -326,21 +355,30 @@ if (outstyle) {		/* two ascii files */
 	bubulles_to_data(outfname, NULL, bublist, 0);
 	// edges_to_data(file_edges, edges, 0);
 	}
-else	{		/* one 'evblob' file */
-	strcpy(outfname, infname);
-	/* see manpage basename(3) */
-	baseptr = basename(outfname);
-	// fprintf(stderr, "baseptr -> [%s]\n", baseptr);
-	cptr = rindex(baseptr, '.');
-	strcpy(cptr, ".evblob");
-	// fprintf(stderr, "baseptr-> [%s]\n", baseptr);
-	foo = x_write_vertedges(baseptr, bublist, edges);
+else	{					/* one 'evblob' file */
+	if (NULL == ofname) {
+		strcpy(outfname, infname);
+		/* see manpage basename(3) */
+		baseptr = basename(outfname);
+		// fprintf(stderr, "baseptr -> [%s]\n", baseptr);
+		cptr = rindex(baseptr, '.');
+		strcpy(cptr, ".evblob");
+		fprintf(stderr, "baseptr-> [%s]\n", baseptr);
+		cptr = baseptr;
+		}
+	else	{
+		cptr = ofname;
+		fprintf(stderr, "writing to %s\n", cptr);
+		}
+	foo = x_write_vertedges(cptr, bublist, edges);
+
 	if (foo) {
 		fprintf(stderr, "Err #%d when writing edges&vertices file\n", foo);
 		}
 	}
 
 // Cleanup
+free(outfname);
 free_bubulles(bublist, 0);
 free_edgelist(edges, 0);
 

tools/minimal.obj

@@ -1,7 +1,11 @@
 o minimal
+
 v 0 0 0
 v 1 0 0
-v 0 1 0
-v 0 0 1
-f 1/2 2/3 3/1
-f 0/1 0/1 0/2
+v 0 2 0
+v 0 0 3
+
+f 0 1 2
+f 1 2 3
+f 3 1 0
+f 0 2 3

tools/objtrucs.h

@@ -1,7 +1,8 @@
 /*
  *		EXPERIMENTAL CODE !
  *
- *	see also 'rdwredges.c' & 'export_evblob.c'
+ *	see  'rdwredges.c'       for source code
+ *        &  'export_evblob.c'   for a usecase.
  */
 
 #define  EVBLOB_MAGIC    (65872139)
@@ -14,8 +15,8 @@ typedef struct {
 	} EdgesAndVertices;
 
 /* in importobj.c */
-int try_to_read_an_OBJ_file(char *fname, int outstyle);
+int try_to_read_an_OBJ_file(char *fname, char *oname, int outstyle);
 
 /* in rdwredges.c */
-int x_write_vertedges(char *filename, BBList *bblist, EdgeList *edges);
-int x_load_vertedges(char *filename, EdgesAndVertices *eav);
+int x_write_vertedges (char *filename, BBList *bblist, EdgeList *edges);
+int x_load_vertedges  (char *filename, EdgesAndVertices *eav);

tools/overflowed.obj

@@ -0,0 +1,11 @@
+o minimal
+
+v 0 0 0
+v 1 0 0
+v 0 2 0
+v 0 0 3
+
+f 0 1 2
+f 2 3 4
+f 4 2 1
+f 0 3 4

tools/rdwredges.c

@@ -26,9 +26,13 @@ int		idx;
 unsigned char	*cptr = (unsigned char *)ptr;
 
 for (idx=0; idx<count; idx++) {
-	fprintf(stderr, "%02x", cptr[idx]);
+	fprintf(stderr, "%02x ", cptr[idx]);
 	}
-fprintf(stderr, " ?\n");
+fprintf(stderr, "    ?\n");
+for (idx=0; idx<count; idx++) {
+	fprintf(stderr, " %c ", isprint(cptr[idx]) ? cptr[idx] : 'X' );
+	}
+fprintf(stderr, "    ?\n");
 }
 /* --------------------------------------------------------------------- */
 /*			EXPERIMENTAL GRUIK-CODE !!!			 */
@@ -112,7 +116,7 @@ if (1 != foo) {
 	fprintf(stderr, "    %s of '%s': short read %d\n", __func__, filename, foo);
 	return -1;
 	}
-fprintf(stderr, "    %d vertices to be loaded\n", nbre);
+if (verbosity) fprintf(stderr, "    %d vertices to be loaded\n", nbre);
 
 /* allocate memory */
 blst = alloc_bubulles(filename, nbre, 0);
@@ -151,7 +155,7 @@ if (1 != foo) {
 	fprintf(stderr, "    %s of '%s': short read %d\n", __func__, filename, foo);
 	return -1;
 	}
-fprintf(stderr, "    %d edges to be loaded\n", nbre);
+if (verbosity) fprintf(stderr, "    %d edges to be loaded\n", nbre);
 
 /* allocate memory for edges list */
 elst = alloc_edgelist("krkrkr", nbre, 0);

tools/read_obj.c

@@ -5,6 +5,7 @@
 #include	<stdio.h>
 #include	<stdlib.h>
 #include	<libgen.h>		// for basename(3)
+#include        <unistd.h>
 
 #include	"../bubulles.h"
 #include	"../edges.h"
@@ -13,22 +14,60 @@
 
 int	verbosity = 0;
 
+/* --------------------------------------------------------------------- */
+void help(void)
+{
+printf("### READ_OBJ       0X%X TALKING\n", getpid());
+puts("usage:");
+puts("\t-h\t\tthis help (use -v -h for more");
+puts("\t-o fname\tfix the output filename");
+puts("\t-v\t\tincrease verbosity");
+
+exit(0);
+}
+/* --------------------------------------------------------------------- */
+
 int main(int argc, char *argv[])
 {
-int		foo;
-char		*fname;		/* see manpage basename(3) */
+int		foo, opt;
+char		*ofname = NULL;
 
-fprintf(stderr, "\n### READ_OBJ       compiled %s at %s\n", __DATE__, __TIME__);
+fprintf(stderr, "### READ_OBJ       compiled %s at %s\n", __DATE__, __TIME__);
 
-if (2 != argc) {
+if (1 == argc) {
 	bubulles_version(1);
 	exit(0);
 	}
 
-verbosity = 0;
+while ((opt = getopt(argc, argv, "ho:v")) != -1) {
+	switch(opt) {
+		case 'h':
+			help();			break;
+		case 'o':
+			ofname = optarg;
+			break;
+		case 'v':
+			verbosity++;		break;
+		default:
+			exit(1);
+			break;
+		}
+	}
 
-foo = try_to_read_an_OBJ_file(argv[1], 0);
-fprintf(stderr, "try to read '%s' -> %d\n", argv [1], foo);
+if (optind < argc) {
+	if (verbosity) fprintf(stderr, "    arg[%d] = %s\n",
+					optind, argv[optind]);
+	foo = try_to_read_an_OBJ_file(argv[optind], ofname, 0);
+	if (foo) {
+		fprintf(stderr, "Error number %d on '%s'\n",
+						foo, argv[optind]);
+		exit(1);
+		}
+	}
+else	{
+	fprintf(stderr, "%s need a input filename\n", argv[0]);
+	exit(1);
+	}
 
 return 0;
 }

tools/run_read_export.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+set -e
+
+make read_obj
+make export_evblob
+
+echo "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
+figlet 'a real WTF' | sed 's/^/XXX  /'
+echo "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
+
+./read_obj -v minimal.obj
+
+echo "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
+
+./export_evblob -t edges minimal.evblob		|
+	awk '{ printf "%4d  |  %.0f  %.0f  %.0f    %.0f  %.0f  %.0f\n", \
+			NR, $1, $2, $3,	$4, $5, $6 }'
+echo
+
+./export_evblob -t vertices minimal.evblob
+
+

tools/technique.md

@@ -0,0 +1,37 @@
+# Technique
+
+Les détails **gores**...
+
+## Le parser
+
+Je pense qu'il y a un bug sournois caché dedans
+
+## L'exporteur
+
+Conversion d'un `.evblob` en données tabulées exploitables par
+des scripts `awk`.
+
+## Tests
+
+Pour le moment rien, à part ce fichier .OBJ vérolé :
+
+```
+o minimal
+
+v 0 0 0
+v 1 0 0
+v 0 2 0
+v 0 0 3
+
+f 0 1 2
+f 2 3 4
+f 4 2 1
+f 0 3 4
+```
+
+Ça va, vous avez capté le souci ?
+
+## Conclusion
+
+Rien ,'est simple, tout se complique...
+