X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;ds=sidebyside;f=org.simantics.g3d.occ%2Fsrc%2Forg%2Fsimantics%2Fproconf%2Fg3d%2Focc%2Fgeometry%2FViewableShapeImpl.java;fp=org.simantics.g3d.occ%2Fsrc%2Forg%2Fsimantics%2Fproconf%2Fg3d%2Focc%2Fgeometry%2FViewableShapeImpl.java;h=194b68b2f09ec4335e9662e3c1d98c9203823d13;hb=55702d303318f9d3dc0b5e20010cfc2c4ae0b88e;hp=0000000000000000000000000000000000000000;hpb=fc5d062114ad0f50740374b599ce547fd1a88ec3;p=simantics%2F3d.git

diff --git a/org.simantics.g3d.occ/src/org/simantics/proconf/g3d/occ/geometry/ViewableShapeImpl.java b/org.simantics.g3d.occ/src/org/simantics/proconf/g3d/occ/geometry/ViewableShapeImpl.java
new file mode 100644
index 00000000..194b68b2
--- /dev/null
+++ b/org.simantics.g3d.occ/src/org/simantics/proconf/g3d/occ/geometry/ViewableShapeImpl.java
@@ -0,0 +1,498 @@
+/*******************************************************************************
+ * Copyright (c) 2007- VTT Technical Research Centre of Finland.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     VTT Technical Research Centre of Finland - initial API and implementation
+ *******************************************************************************/
+/* 
+   This class is combination of jCAE's classes to generate meshes from shapes.
+   Faces are lisetd as individual meshes.
+   
+   Marko Luukkainen
+   
+   jCAE stand for Java Computer Aided Engineering. Features are : Small CAD
+   modeler, Finit element mesher, Plugin architecture.
+
+    Copyright (C) 2003 Jerome Robert <jeromerobert@users.sourceforge.net>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+package org.simantics.proconf.g3d.occ.geometry;
+import org.jcae.opencascade.jni.BRepBndLib;
+import org.jcae.opencascade.jni.BRepMesh_IncrementalMesh;
+import org.jcae.opencascade.jni.BRepTools;
+import org.jcae.opencascade.jni.BRep_Tool;
+import org.jcae.opencascade.jni.Bnd_Box;
+import org.jcae.opencascade.jni.GCPnts_UniformDeflection;
+import org.jcae.opencascade.jni.GP_Trsf;
+import org.jcae.opencascade.jni.GeomAPI_ProjectPointOnSurf;
+import org.jcae.opencascade.jni.GeomAdaptor_Curve;
+import org.jcae.opencascade.jni.GeomLProp_SLProps;
+import org.jcae.opencascade.jni.Geom_Curve;
+import org.jcae.opencascade.jni.Geom_Surface;
+import org.jcae.opencascade.jni.Poly_Triangulation;
+import org.jcae.opencascade.jni.TopAbs_Orientation;
+import org.jcae.opencascade.jni.TopAbs_ShapeEnum;
+import org.jcae.opencascade.jni.TopExp_Explorer;
+import org.jcae.opencascade.jni.TopLoc_Location;
+import org.jcae.opencascade.jni.TopoDS_Edge;
+import org.jcae.opencascade.jni.TopoDS_Face;
+import org.jcae.opencascade.jni.TopoDS_Shape;
+import org.jcae.opencascade.jni.TopoDS_Vertex;
+
+
+import java.util.ArrayList;
+import java.util.HashSet;
+
+import javax.vecmath.Matrix4d;
+import javax.vecmath.Point3d;
+import javax.vecmath.Vector3f;
+
+
+public class ViewableShapeImpl 
+{
+
+    
+    ArrayList<IndexedGeometry> faceMeshes =new ArrayList<IndexedGeometry>();
+    ArrayList<float[]> edges=new ArrayList<float[]>();
+
+	public ViewableShapeImpl(TopoDS_Shape g)
+	{
+        BRepTools.clean(g);
+		buildFaces(g);
+        buildEdges(g);
+		
+	}
+    /*
+    public ViewableShapeImpl(TopoDS_Shape g, boolean alternative)
+    {
+        
+        if (alternative) 
+            buildFaces(g);
+        else {
+            BRepTools.clean(g);
+            buildFaces2(g);
+        }
+            
+        buildEdges(g);
+        
+    }
+	*/
+	
+	public IndexedGeometry getGeometry(int i)
+	{     
+		return faceMeshes.get(i);
+	}
+	
+	public int numGeometries()
+	{
+        return faceMeshes.size();
+
+	}	
+    
+    public int getNumEdges() {
+        return edges.size();
+    }
+    
+    public float[] getEdge(int i) {
+        return edges.get(i);
+    }
+    
+    /**
+     * org.jcae.viewer3d.cad.occ.OCCEdgeDomain
+     * @param shape
+     * @param geom
+     */
+    private void buildFaces(TopoDS_Shape shape) {
+        TopExp_Explorer explorer = new TopExp_Explorer();
+        TopLoc_Location loc = new TopLoc_Location();
+        
+        int meshIter=4;
+        double deflection = deflection(shape);
+        for (explorer.init(shape, TopAbs_ShapeEnum.FACE); explorer.more(); explorer.next())
+        {       
+            //System.out.println("Triangulation");
+            TopoDS_Shape s = explorer.current();
+            if (!(s instanceof TopoDS_Face)) continue; // should not happen!
+            TopoDS_Face face = (TopoDS_Face)s;
+            Poly_Triangulation pt = BRep_Tool.triangulation(face,loc);
+            
+            //float error=0.01f;
+            double error = deflection;
+            int iter=0;
+            // if shape was generated with program triangulation seems to be always null,
+            // but model is loaded from file, it may already contain triangulation
+            // So : in those cases can we delete existing triangulation and generate a new one ?
+            //if (pt == null) {
+                //System.out.println("Initial triangulation of face "+face+" not found. Using Incremental mesh");
+            //} else {
+            	//System.out.println("Initial triangulation of face "+face+" found.");
+            //}
+            while((pt==null)&(iter<meshIter)){
+                //System.out.println("Triangulation failed for face "+face+". Trying other mesh parameters.");
+                
+                // using relatif in incremental mesh would cause visible seams between faces
+            	BRepMesh_IncrementalMesh m = new BRepMesh_IncrementalMesh(face,error, false);
+                //new BRepMesh_IncrementalMesh(face,error, false,12.0);
+                pt = BRep_Tool.triangulation(face,loc);             
+                error/=10;
+                iter++;
+                m.delete();
+                
+            }
+                          
+            
+            if (pt==null)
+            {
+                System.out.println("Triangulation failed for face "+face+". Mesh not generated.");
+                continue;
+ 
+            }
+            
+            GP_Trsf trsf = loc.transformation();
+            double[] mat = new double[16];
+            trsf.getValues(mat);
+            Matrix4d m = new Matrix4d(mat);
+            
+            double[] dnodes = pt.nodes();
+            final int[] itriangles = pt.triangles();   
+            boolean useNormals = false;
+            boolean useTCoord = false;
+            
+            float[] tnodes = null;
+            float[] normals = null;
+            
+            if (useTCoord)
+            	tnodes = new float[dnodes.length / 3 * 2];
+            if (useNormals)
+            	normals= new float[dnodes.length];
+            GeomLProp_SLProps prop = new GeomLProp_SLProps(2,0.001);
+            Geom_Surface surf = BRep_Tool.surface(face);
+            prop.setSurface(surf);
+            if (useTCoord || useNormals) {
+            	for (int i = 0; i < dnodes.length; i += 3) {
+					double UV[] = new double[2];
+					double point[] = new double[] { dnodes[i], dnodes[i + 1],
+							dnodes[i + 2] };
+					GeomAPI_ProjectPointOnSurf pof = new GeomAPI_ProjectPointOnSurf(
+							point, surf);
+					pof.lowerDistanceParameters(UV);
+					// boolean b = GeomLib_Tool.parameters(surf, point, 0.01,
+					// UV);
+					prop.setParameters(UV[0], UV[1]);
+					if (useNormals) {
+						double normal[] = prop.normal();
+						normals[i] = (float) normal[0];
+						normals[i + 1] = (float) normal[1];
+						normals[i + 2] = (float) normal[2];
+					}
+					if (useTCoord) {
+						int index = i / 3 * 2;
+						tnodes[index] = (float) UV[0];
+						tnodes[index + 1] = (float) UV[1];
+					}
+					// System.out.println(dnodes[i]+ " " +dnodes[i+1]+ " "
+					// +dnodes[i+2]+ " " + " UV:" + UV[0] + ","+UV[1]+ " " + b);
+					// System.out.println(dnodes[i]+ " " +dnodes[i+1]+ " "
+					// +dnodes[i+2]+ " " + normals[i] + " " + normals[i+1] + " "
+					// + normals[i+2] + " UV:" + UV[0] + ","+UV[1]);
+				}
+            }
+            prop.delete();
+            
+            if(face.orientation()==TopAbs_Orientation.REVERSED)
+            {
+                flipFace(itriangles);
+            }
+            
+            final float[] fnodes=createFloatVertices(dnodes, m);
+            IndexedGeometry geom = new IndexedGeometry();
+            geom.setCoordinates(fnodes);
+            geom.setIndices(itriangles);
+            geom.setNormals(calcNormals(fnodes,itriangles));
+            if (useNormals)
+            	geom.setNormals(normals);
+            if (useTCoord)
+            	geom.setTCoordinates(tnodes);
+            faceMeshes.add(geom);
+            //System.out.println("Triangulation done");
+        }
+    }
+    
+    /**
+     * org.jcae.viewer3d.cad.occ.OCCEdgeDomain
+     * @param shape
+     * @param geom
+     */
+    /*
+    private void buildFaces2(TopoDS_Shape shape) {
+
+            TopExp_Explorer explorer = new TopExp_Explorer();
+            TopLoc_Location loc = new TopLoc_Location();
+            
+            int meshIter=10;
+                    
+            for (explorer.init(shape, TopAbs_ShapeEnum.FACE); explorer.more(); explorer.next())
+            {                       
+                TopoDS_Shape s = explorer.current();
+                if (!(s instanceof TopoDS_Face)) continue; // should not happen!
+                TopoDS_Face face = (TopoDS_Face)s;
+               
+                double error=0.01;
+                BRepMesh_Discret mesh = new BRepMesh_Discret(0.01,face,0.1,true,true);
+                Poly_Triangulation pt = BRep_Tool.triangulation(face,loc);
+                //float error=0.001f*getMaxBound(s)*4;
+                
+                if (pt == null) {
+                    System.out.println("Triangulation failed for face "+face+". Using Incremental mesh");
+                }
+                
+                int iter=0;
+                while((pt==null)&(iter<meshIter)){
+                	BRepMesh_IncrementalMesh m = new BRepMesh_IncrementalMesh(face,error, false);
+                    //new BRepMesh_IncrementalMesh(face,error, true);
+                    pt = BRep_Tool.triangulation(face,loc);             
+                    error/=100;
+                    iter++;
+                    System.out.println("Triangulation failed for face "+face+". Trying other mesh parameters.");
+                    m.delete();
+                }
+                mesh.delete();
+                if (pt==null)
+                {
+                    System.out.println("Triangulation failed for face "+face+". Mesh not generated.");
+                    continue;
+                }
+                GP_Trsf trsf = loc.transformation();
+                double[] mat = new double[16];
+                trsf.getValues(mat);
+                Matrix4d m = new Matrix4d(mat);
+                
+                double[] dnodes = pt.nodes();
+                final int[] itriangles = pt.triangles();                        
+
+                if(face.orientation()==TopAbs_Orientation.REVERSED)
+                {
+                    flipFace(itriangles);
+                }
+                
+                final float[] fnodes=createFloatVertices(dnodes, m);
+                IndexedGeometry geom = new IndexedGeometry();
+                geom.setCoordinates(fnodes);
+                geom.setIndices(itriangles);
+                geom.setNormals(calcNormals(fnodes,itriangles));
+                faceMeshes.add(geom);
+            }
+    }
+    */
+    
+    private float[] createFloatVertices(double dnodes[], Matrix4d m) {
+        float[] fnodes=new float[dnodes.length];
+        Point3d p = new Point3d();
+        
+        for(int i=0; i<dnodes.length;)
+        {
+            p.x = dnodes[i];
+            p.y = dnodes[i+1];
+            p.z = dnodes[i+2];
+            m.transform(p);
+            fnodes[i++]=(float) p.x;
+            fnodes[i++]=(float) p.y;
+            fnodes[i++]=(float) p.z;  
+        }
+        return fnodes;
+    }
+    private double deflection(TopoDS_Shape s) {
+    	Bnd_Box box = new Bnd_Box(); 
+        BRepBndLib.add(s,box);
+        
+        double[] bbox = box.get();
+        double boundingBoxDeflection=0.01*
+            Math.max(Math.max(bbox[3]-bbox[0], bbox[4]-bbox[1]), bbox[5]-bbox[2]);
+        box.delete();
+        return boundingBoxDeflection;
+    }
+    
+    private double edgeDeflection(TopoDS_Shape s) {
+    	return 0.5 * deflection(s);
+    }
+    
+    /**
+     * org.jcae.viewer3d.cad.occ.OCCEdgeDomain
+     * @param shape
+     * @param geom
+     */
+    private void buildEdges(TopoDS_Shape shape) {
+        
+        
+        TopExp_Explorer explorer = new TopExp_Explorer();
+        HashSet<TopoDS_Edge> alreadyDone=new HashSet<TopoDS_Edge>();
+        double boundingBoxDeflection = edgeDeflection(shape);
+
+        for (explorer.init(shape, TopAbs_ShapeEnum.EDGE); explorer.more(); explorer.next())
+        {
+            TopoDS_Shape s = explorer.current();            
+            if (!(s instanceof TopoDS_Edge)) continue; // should not happen!
+            TopoDS_Edge e = (TopoDS_Edge)s;
+            
+            if(!alreadyDone.add(e))
+                continue;
+                        
+            double[] range = BRep_Tool.range(e);
+            Geom_Curve gc = BRep_Tool.curve(e, range);
+            float[] array;
+            if(gc!=null)
+            {
+                GeomAdaptor_Curve adaptator = new GeomAdaptor_Curve(gc);
+                GCPnts_UniformDeflection deflector = new GCPnts_UniformDeflection();
+
+                deflector.initialize(adaptator, boundingBoxDeflection, range[0], range[1]);
+                int npts = deflector.nbPoints();
+                
+                // Allocate one additional point at each end  = parametric value 0, 1
+                int size = 0;
+                if (npts > 2)
+                    size = (npts-2)*2;
+                size+=2;
+                size*=3;
+                array = new float[size];          
+                int j=0;
+                double[] values = adaptator.value(range[0]);
+                array[j++] = (float) values[0];
+                array[j++] = (float) values[1];
+                array[j++] = (float) values[2];
+                // All intermediary points
+                for (int i=1; i<npts-1; ++i) {
+                    values = adaptator.value(deflector.parameter(i+1));
+                    array[j++] = (float) values[0];
+                    array[j++] = (float) values[1];
+                    array[j++] = (float) values[2];
+                    array[j++] = (float) values[0];
+                    array[j++] = (float) values[1];
+                    array[j++] = (float) values[2];
+                }
+                // Add last point
+                values = adaptator.value(range[1]);
+                array[j++] = (float) values[0];
+                array[j++] = (float) values[1];
+                array[j++] = (float) values[2];
+                edges.add(array);
+                adaptator.delete();
+                deflector.delete();
+            }
+            else
+            {
+                if (!BRep_Tool.degenerated(e))
+                {
+                    // So, there is no curve, and the edge is not degenerated?
+                    // => draw lines between the vertices and ignore curvature  
+                    // best approximation we can do
+                    ArrayList<double[]> aa = new ArrayList<double[]>(); // store points here
+                    for (TopExp_Explorer explorer2 = new TopExp_Explorer(s, TopAbs_ShapeEnum.VERTEX);
+                        explorer2.more(); explorer2.next())
+                    {
+                        TopoDS_Shape sv = explorer2.current();
+                        if (!(sv instanceof TopoDS_Vertex)) continue; // should not happen!
+                        TopoDS_Vertex v = (TopoDS_Vertex)sv;
+                        aa.add(BRep_Tool.pnt(v));
+                    }
+                    int size = 0;
+                    if (aa.size() > 2)
+                        size = (aa.size()-2)*2;
+                    size+=2;
+                    double[] f=(double[])aa.get(0);
+                    array = new float[size*3];
+                    array[0]=(float) f[0];
+                    array[1]=(float) f[1];
+                    array[2]=(float) f[2];
+                    for(int i=1, j=3; i<aa.size()-1; i++)
+                    {
+                        f=aa.get(i);
+                        array[j++]=(float) f[0];
+                        array[j++]=(float) f[1];
+                        array[j++]=(float) f[2];
+                        array[j++]=(float) f[0];
+                        array[j++]=(float) f[1];
+                        array[j++]=(float) f[2];
+                    }
+                    f=aa.get(aa.size()-1);
+                    array[array.length-3]=(float) f[0];
+                    array[array.length-2]=(float) f[1];
+                    array[array.length-1]=(float) f[2];
+                    edges.add(array);
+                }
+            }
+        }       
+    }
+    
+    private float[] calcNormals(float[] fnodes, int[] trias) {
+        float nnodes[] = new float[fnodes.length];
+        for (int i = 0; i < nnodes.length; i++) nnodes[i] = 0.f;
+        Vector3f v1 = new Vector3f();
+        Vector3f v2 = new Vector3f();
+        Vector3f v3 = new Vector3f();
+        Vector3f t1 = new Vector3f();
+        Vector3f t2 = new Vector3f();
+        Vector3f n = new Vector3f();
+        for (int i = 0; i < trias.length; i+=3) {
+            v1.x = fnodes[trias[i]*3];
+            v1.y = fnodes[trias[i]*3+1];
+            v1.z = fnodes[trias[i]*3+2];
+            v2.x = fnodes[trias[i+1]*3];
+            v2.y = fnodes[trias[i+1]*3+1];
+            v2.z = fnodes[trias[i+1]*3+2];
+            v3.x = fnodes[trias[i+2]*3];
+            v3.y = fnodes[trias[i+2]*3+1];
+            v3.z = fnodes[trias[i+2]*3+2];
+            t1.sub(v3, v1);
+            t2.sub(v2, v1);
+            n.cross(t2, t1);
+            //n.normalize();
+            nnodes[trias[i]*3] += n.x;
+            nnodes[trias[i]*3+1] += n.y;
+            nnodes[trias[i]*3+2] += n.z;
+            nnodes[trias[i+1]*3] += n.x;
+            nnodes[trias[i+1]*3+1] += n.y;
+            nnodes[trias[i+1]*3+2] += n.z;
+            nnodes[trias[i+2]*3] += n.x;
+            nnodes[trias[i+2]*3+1] += n.y;
+            nnodes[trias[i+2]*3+2] += n.z;
+        }
+        for (int i = 0; i < nnodes.length; i+=3) {
+            n.x = nnodes[i];
+            n.y = nnodes[i+1];
+            n.z = nnodes[i+2];
+            n.normalize();
+            nnodes[i] = n.x;
+            nnodes[i+1] = n.y;
+            nnodes[i+2] = n.z;
+        }
+        return nnodes;
+    }
+    
+    private void flipFace(int[] trias) {
+        int newTrias[] = new int[trias.length];
+        System.arraycopy(trias, 0, newTrias, 0, trias.length);
+        for (int i = 0; i < trias.length; i++) {
+            trias[i] = newTrias[trias.length - i - 1];
+        }
+    }	
+	
+}