Now we are going to demonstrate how we prepare a model file for OpenGL rendering pipeline.

void initModel () { model.initFromFile(fn); model.OBJ_SIZE =10.0f; //model.print(); model.printBounding(); model.calculateScale(); model.offSet(); model.calculateTrianglesNormals(); }

The initFromFile(String fn) is pretty long. It was literally transalted from the C program I wrote some years ago. Due to no IDE or the IDE is so poor for programming in C, keeping everything in one file eases keyword/string search.

/** * @param fn this file name must be file name without directory, and it is in the resource folder. */ public void initFromFile (final String fn){ //GLfloat xmin,xmax,ymin,ymax,zmin,zmax; //xmin = xmax= ymin= ymax= zmin= zmax = 0; float x=0.0f, y=0.0f, z=0.0f; float minedge=0.0f,maxedge=0.0f,tmpe1=0.0f,tmpe2=0.0f; // number of vertices, edges? TODO, number of triangles int nv=0,ns=0,nt=0; int v1=0,v2=0; int t1=0,t2=0,t3=0; // GTSEdge tmpep = new GTSEdge (new Edge(0,0), -1, -1); Edge tmpep = new Edge(0,0); Triangle tmpt = new Triangle (0,0,0); Point tmpp = new Point (0.0f,0.0f,0.0f ); URL fileURL = GTSFileReader.class.getClassLoader().getResource(new File(fn).getName()); boolean succeeded = false; FileInputStream fis = null; BufferedReader br = null; try { fis = new FileInputStream(new File(fileURL.toURI())); //Construct BufferedReader from InputStreamReader br = new BufferedReader(new InputStreamReader(fis)); //Read the first line, to get totalVertices, totalEdges, totalTriangles String line = br.readLine(); if (null != line ) { String strFirstLine = line; String[] indices = strFirstLine.split("\\s"); try { this.verticesCount = Integer.parseInt(indices[0]); this.edgesCount = Integer.parseInt(indices[1]); this.trianglesCount = Integer.parseInt(indices[2]); } catch (Exception e) { System.out.println("Fail to parse header."); //throw again to goto disaster handle. throw new Exception("Fail to parse header."); } } else { System.out.println("Fail to read the first line."); throw new Exception("Fail to read the first line."); } // vertex (x,y,z); edge (beginVertexIndex, endVertexIndex); triangle (edgeOneIndex,edgeTwoIndex,edgeThreeIndex) //End read the first line this.vertices = new Vertex[this.verticesCount] ; this.edges = new GTSEdge[this.edgesCount] ; this.triangles = new GTSTriangle[this.trianglesCount]; { //Read the vertices (geometry) int count = 0; for (int i = 0 ; i < this.verticesCount; i++) { try { line = br.readLine(); String [] arr = line.split("\\s"); x = Float.parseFloat(arr[0]); count++; y = Float.parseFloat(arr[1]); count++; z = Float.parseFloat(arr[2]); count++; tmpp.x = x; tmpp.y = y ; tmpp.z = z; //mp->addAVertex(tmpp); addAVertexToVlist(tmpp,i+1,COMMON_VERTEX); xmin = (xmin < x)?xmin:x; ymin = (ymin < y)?ymin:y; zmin = (zmin < z)?zmin:z; xmax = (xmax > x)?xmax:x; ymax = (ymax > y)?ymax:y; zmax = (zmax > z)?zmax:z; } catch (Exception e) { System.out.println("Fail to parse vertex at row "+(i)); //throw again to goto disaster handle. throw new Exception("Fail to parse vertex at row "+(i)); } } if (count != this.verticesCount * 3) { throw new Exception("Read vertices "); } //Read the vertices (geometry) } { //TO-DO metaphorically read the edges the same way int count = 0; for (int i = 0 ; i < this.edgesCount; i++) { try { line = br.readLine(); String [] arr = line.split("\\s"); v1 = Integer.parseInt(arr[0]); count++; v2 = Integer.parseInt(arr[1]); count++; tmpep.beg = v1; tmpep.fin = v2; addAnEdge(tmpep,i+1,VALID_EDGE); //TODO where is tmpe1 computed it is the current edges' length, is it used later. // if (minedge == 0.0) // minedge = tmpe1; // // minedge = (minedge < tmpe1 )?minedge:tmpe1; // maxedge = (maxedge > tmpe1 )?maxedge:tmpe1; } catch (Exception e) { System.out.println("Fail to parse edge at edge row "+(i)); //throw again to goto disaster handle. throw new Exception("Fail to parse edge at edge row "+(i)); } } if (count != this.edgesCount * 2) { throw new Exception("Read edges "); } } { //TO-DO metaphorically read the triangles int count = 0; for (int i = 0 ; i < this.trianglesCount; i++) { try { line = br.readLine(); String [] arr = line.split("\\s"); tmpt.e1 = Integer.parseInt(arr[0]); count++; tmpt.e2 = Integer.parseInt(arr[1]); count++; tmpt.e3 = Integer.parseInt(arr[2]); addATriangle(tmpt,i+1,VALID_TRIANGLE); count++; } catch (Exception e) { System.out.println("Fail to parse triangle at triangle row "+(i)); //throw again to goto disaster handle. throw new Exception("Fail to parse triangle at triangle row "+(i)); } } if (count != this.trianglesCount * 3) { throw new Exception("Read triangles "); } } succeeded =true; } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } catch (URISyntaxException e) { e.printStackTrace(); } catch (Exception eat) { eat.printStackTrace(); } finally { if (null != br) { try { br.close(); } catch (IOException e) { e.printStackTrace(); } } if (null != fis) { try { fis.close(); } catch (IOException e) { e.printStackTrace(); } } } }

The functions compose of three main parts, add a vertex, add an edge and add a triangle to our customized data structure. These steps are consistent with the structure of a GTS model file. In addition, we also compute the bounding box of the model, namely the xmin, ymin, zmin and xmax, ymax, zmax. If we try to translate and scale a model to fit into a given camera setting, the geometry information of the bounding box is very necessary.

The Java implementation of addAVertexToVlist eases us
protected int addAVertexToVlist( Point p, final int ci, final int attr) { vertices[this.verticesCountOrigin] = new Vertex(new Point (p.x,p.y,p.z),ci,attr); return ++verticesCountOrigin; };

Comparing the C implementation, where we wrote a heap by ourselves, the Java array is easy to read. C array is also feasible, but as far as I remember it has limit differs at different OSs or C implementations. Sometime it is so complicated to remember why you have done that and asking too many whys are difficult to answer until you took great pains to keep notes at every line you wrote, then another question may be raised why you keep so many notes. Query is good and looks endeavoring but research and literature take pains.
int Model::addAVertexToVlist( Point * p, int ci, int attr) { int success = -1; int i = 0; if (verticesCount + 1 > verticesLimit) { Vertex ** tmp; tmp = (Vertex **) malloc ( sizeof(Vertex * ) * verticesLimit * 2); for (i = 0; i<verticesCount; i++) { tmp[i] = vertices[i]; } tmp[i] = new Vertex(p,ci,attr); for (i = verticesCount+1; i< verticesLimit * 2; i++) tmp[i] = NULL; delete [] vertices; vertices = tmp; verticesLimit = verticesLimit * 2; } else vertices[verticesCount] = new Vertex(p,ci,attr); ++verticesCountOrigin; return ++verticesCount; };

The customized pointerish heap implementation also bizzarely crashed the program at random due to the limited knowlege/expertise of handling such situation. This does not say Java implementation resovles the above mentioned situation. In fact, when operating any machine, we have to tune it ourselves or get somebody else to do that so we won't put the machine to a stall. JVM's graphical interface makes such practice possible.

Then the data structure and implementation for edges can be referring to that of vertices. In model processing, we know that the edges keep the information of the topological structure namely the connectivity. We also need each vertex knows which and how many edges connects to it, so we can reach to other vertices. Each edge has two vertices. Two vertices share a same edge.

protected int addAnEdge(Edge pgp,int nindex,int nattrib ) throws Exception{ GTSEdge edge = new GTSEdge( new Edge(pgp.beg,pgp.fin),nindex,nattrib); this.edges[this.edgesCountOrigin] = edge; vertices[(pgp.beg)-1].addAnEdge(edge); vertices[(pgp.fin)-1].addAnEdge(edge); return ++edgesCountOrigin; }

If we want to talk about the completeness of a 2-manifold, I think here we can count the triangles it has or neighboring vertices that don't share one same triangle, so we can tell if this particular manifold has a hole. It is worth noting that GTS records a triangle by the three edges it has. An edge connects two vertices. So if we want to know the vertex-triangle relationship, we need extra effort. The edges' sequence of a triangle is important because it decides the orientation of the triangle, CCW or CW, which denoted as counter-clock-wise or clock-wise.

protected int addATriangle(Triangle pgp,int nindex,int nattrib ){ //addATriangleToTlist(GTStriangle * pgt,int nindex,int nattrib); GTSTriangle triangle = new GTSTriangle(new Triangle (pgp.e1,pgp.e2,pgp.e3),nindex,nattrib); this.triangles[this.trianglesCountOrigin] = triangle; //modeltriangle * tmpp = addATriangleToTlist(pgp,nindex,nattrib ); int v1,v2,v3,tmp; tmp = v1 = v2 = v3 = -1; //if pgp->e1 if ((edges[pgp.e1-1]).gp.beg == (edges[pgp.e2-1]).gp.beg ) v1 = (edges[pgp.e1-1]).gp.beg ; else { if ((edges[pgp.e1-1]).gp.beg == (edges[pgp.e2-1]).gp.fin ) v1 = (edges[pgp.e1-1]).gp.beg ; else v1 = (edges[pgp.e1-1]).gp.fin ; } if (v1 == (edges[pgp.e2-1]).gp.beg ) v2 = (edges[pgp.e2-1]).gp.fin ; else v2 = (edges[pgp.e2-1]).gp.beg ; if (v2 == (edges[pgp.e3-1]).gp.beg ) v3 = (edges[pgp.e3-1]).gp.fin ; else v3 = (edges[pgp.e3-1]).gp.beg ; vertices[v1-1].addATriangle(triangle); vertices[v2-1].addATriangle(triangle); vertices[v3-1].addATriangle(triangle); return ++trianglesCountOrigin; };