From f1c718cce66e5651a0dae91375db6ebfaded1a92 Mon Sep 17 00:00:00 2001
From: Normand Briere <nbriere@noware.ca>
Date: Sat, 27 Apr 2019 21:33:41 -0400
Subject: [PATCH] Test unfold UV

---
 BoundaryRep.java |  262 +++++++++++++++++++++++++++++++++-------------------
 1 files changed, 166 insertions(+), 96 deletions(-)

diff --git a/BoundaryRep.java b/BoundaryRep.java
index d786a91..05b3429 100644
--- a/BoundaryRep.java
+++ b/BoundaryRep.java
@@ -15,7 +15,7 @@
     {
         this(0, 0);
     }
-    
+
     void SaveSupports()
     {
         transientsupport = support;
@@ -790,7 +790,7 @@
             v.weights[k] = other.ComputeWeight(v, toRoot, k); // (float)(supportsize * normalweight * nz / Math.pow(tx*tx+ty*ty+tz*tz, 1));
             v.totalweight += v.weights[k];
             
-            if (CameraPane.CROWD)
+            if (Globals.CROWD)
             {
       //          System.out.print("weight = " + v.weights[k]);
       //          System.out.println("; totalweight = " + v.totalweight);
@@ -2661,18 +2661,18 @@
         if (false) // slow && stepout && onein)
         {
             // sound
-            cVector eye = CameraPane.theRenderer.eyeCamera.location;
+            cVector eye = Globals.theRenderer.EyeCamera().location;
 
             Vertex v = GetVertex(0);
 
             tmp.set(v);
             tmp.sub(eye);
 
-            if (CameraPane.framecount - lastsoundtime > 30) // 0.25 secs
+            if (Globals.framecount - lastsoundtime > 30) // 0.25 secs
             {
                 GrafreeD.wav.play((Math.random()+0.5)/Math.max(tmp.length2(),0.2)); //, 1);
 
-                lastsoundtime = CameraPane.framecount;
+                lastsoundtime = Globals.framecount;
             }
             
             stepout = false;
@@ -3155,7 +3155,27 @@
      */
     }
 
-    void GenUV()
+    void UnfoldUV()
+    {
+            for (int i = 0; i < VertexCount(); i++)
+            {
+                Vertex v = GetVertex(i);
+                
+                v.x = v.s;
+                v.y = v.t;
+                v.z = 0;
+                
+                v.norm.x = 0;
+                v.norm.y = 0;
+                v.norm.z = 1;
+                
+                SetVertex(v, i);
+            }
+    }
+    
+    float power = 2;
+    
+    void GenUV() // float power)
     {
         Trim();
         
@@ -3219,6 +3239,115 @@
                 y -= 0.5;
                 z -= 0.5;
                 
+                double ax = Math.abs(x);
+                double ay = Math.abs(y);
+                double max = ax;
+                if (max < ay)
+                {
+                    max = ay;
+                }
+                
+                x /= max;
+                y /= max;
+
+                double angle = Math.acos(Math.abs(z*2));
+                
+                double k = angle / Math.PI * 2;
+                
+                // k == 0 => uv = 0 (center)
+                // k == 1 => uv = -1,1 (border)
+                
+                if (i == 0)
+                        System.out.println("power = " + power);
+                
+                double length1 = (ax+ay)/max;
+                double length2 = Math.sqrt(ax*ax + ay*ay) / max;
+
+                double t = k;
+                
+                t = Math.pow(t, 3);
+                
+                // Interpolate between k/length2 (center) and k (border)
+                k = k / length2 * (1 - t) + k * t;
+                
+                double u = k*x;
+                double v = k*y;
+
+                u /= 2;
+                v /= 2;
+                u += 0.5;
+                v += 0.5;
+                
+                uvmap[i2] = (float) u;
+                uvmap[i2+1] = (float) v;
+            }
+    }
+        
+    void GenUVold(float power)
+    {
+        Trim();
+        
+        cVector boxcenter = null;
+          cVector minima, maxima;
+            minima = new cVector();
+            maxima = new cVector();
+            minima.x = minima.y = minima.z = Double.MAX_VALUE;
+            maxima.x = maxima.y = maxima.z = -Double.MAX_VALUE;
+            for (int i = 0; i < VertexCount(); i++)
+            {
+                Vertex v = GetVertex(i);
+
+                if (minima.x > v.x)
+                {
+                    minima.x = v.x;
+                }
+                if (minima.y > v.y)
+                {
+                    minima.y = v.y;
+                }
+                if (minima.z > v.z)
+                {
+                    minima.z = v.z;
+                }
+
+                if (maxima.x < v.x)
+                {
+                    maxima.x = v.x;
+                }
+                if (maxima.y < v.y)
+                {
+                    maxima.y = v.y;
+                }
+                if (maxima.z < v.z)
+                {
+                    maxima.z = v.z;
+                }
+            }
+
+            boxcenter = new cVector((maxima.x + minima.x) / 2, (maxima.y + minima.y) / 2, (maxima.z + minima.z) / 2);
+            int i2 = 0, i3 = 0;
+            for (int i = 0; i < positions.length/3; i++, i3 += 3, i2 += 2)
+            {
+//                //uvmap[i2] = (float) normals[i3]*0.5f + 0.5f; // v.x;
+//                //uvmap[i2 + 1] = (float) normals[i3+1]*0.5f + 0.5f; //z;
+//                uvmap[i2] = (float) (positions[i3] - boxcenter.x);
+//                uvmap[i2 + 1] = (float) (positions[i3+2] - boxcenter.z);
+//                uvmap[i2] = (float) Math.atan2(positions[i3+1] - boxcenter.y, positions[i3] - boxcenter.x);
+//                uvmap[i2 + 1] = (float)(positions[i3+2] - boxcenter.z);
+                // box UV
+                double x = positions[i3] - minima.x; // - Math.floor(positions[i3]);
+                double y = positions[i3+1] - minima.y; // - Math.floor(positions[i3+1]);
+                double z = positions[i3+2] - minima.z; // - Math.floor(positions[i3+2]);
+
+                // [-1/2, 1/2]
+                x /= maxima.x - minima.x;
+                y /= maxima.y - minima.y;
+                z /= maxima.z - minima.z;
+                
+                x -= 0.5;
+                y -= 0.5;
+                z -= 0.5;
+                
           //      x *= 2;
           //      y *= 2;
           //      z *= 2;
@@ -3245,6 +3374,15 @@
 
                 z = Math.cos(angle/2);
                 
+                assert(z >= 0);
+                assert(z <= 1);
+                
+                /**/
+                //z = Math.pow(z, power); //1.08f);
+                
+                if (i == 0)
+                        System.out.println("power = " + power);
+                
                 // sqrt(k2*x2 + k2*z2 + y2) = length
                 // k2*x2 + k2*z2 = length2 - y2
                 // k2 = (length2 - y2) / (x2 + z2)
@@ -3264,6 +3402,7 @@
                 
                 x *= k;
                 y *= k;
+                /**/
                 
                 double max = Math.abs(x);
                 if (max < Math.abs(y))
@@ -3276,10 +3415,15 @@
                 }
 
             //    max = Math.sqrt(max*2)/2;
+//                double x2 = Math.pow(Math.abs(x), 1/power);
+//                double y2 = Math.pow(Math.abs(y), 1/power);
+//                double z2 = Math.pow(Math.abs(z), 1/power);
+//                max = Math.pow(x2 + y2 + z2, power);
                 
 //                if (!(max > 0))
-                    assert(max > 0);
-                
+                    //assert(max > 0);
+                    assert(max >= 0);
+                                    
                 x /= max;
                 y /= max;
                 z /= max;
@@ -4428,7 +4572,7 @@
         }
     }
     
-    void CullVertex(javax.media.opengl.GL gl, boolean shadow)
+    void CullVertex(javax.media.opengl.GL glNOTUSED, boolean shadowNOTUSED)
     {
         CameraPane.glu.gluProject(vect5.x,vect5.y,vect5.z,
                 CameraPane.tempmat,0, CameraPane.tempmat2,0,
@@ -4460,14 +4604,14 @@
         // june 2014
 //        Camera parentcam = cam;
 //
-//        if (cam == CameraPane.theRenderer.cameras[0])
+//        if (cam == Globals.theRenderer.cameras[0])
 //        {
-//            parentcam = CameraPane.theRenderer.cameras[1];
+//            parentcam = Globals.theRenderer.cameras[1];
 //        }
 //
-//        if (cam == CameraPane.theRenderer.cameras[1])
+//        if (cam == Globals.theRenderer.cameras[1])
 //        {
-//            parentcam = CameraPane.theRenderer.cameras[0];
+//            parentcam = Globals.theRenderer.cameras[0];
 //        }
     
         gl.glGetDoublev(gl.GL_MODELVIEW_MATRIX, CameraPane.tempmat, 0);
@@ -4893,7 +5037,7 @@
         return verticesCopy;
     }
 
-    void PreprocessOcclusion(CameraPane cp, double[][] transform)
+    void PreprocessOcclusion(iCameraPane cp, double[][] transform)
     {
         if (//!trimmed ||
                 AOdone)
@@ -4902,80 +5046,7 @@
             return;
         }
 
-        Camera keep = cp.renderCamera;
-        cp.renderCamera = localcamera;
-
-        if (trimmed)
-        {
-            float[] colors = new float[positions.length / 3];
-
-            int i3 = 0;
-            for (int i = 0; i < positions.length / 3; i++, i3 += 3)
-            {
-                if (normals[i3] == 0 && normals[i3+1] == 0 && normals[i3+2] == 0)
-                    continue;
-
-                from.set(positions[i3], positions[i3 + 1], positions[i3 + 2]);
-                to.set(positions[i3] + normals[i3],
-                        positions[i3 + 1] + normals[i3 + 1],
-                        positions[i3 + 2] + normals[i3 + 2]);
-                LA.xformPos(from, transform, from);
-                LA.xformPos(to, transform, to); // RIGID ONLY
-                localcamera.setAim(from, to);
-
-                CameraPane.occlusionbuffer.display();
-
-                if (CameraPane.DEBUG_OCCLUSION)
-                    cp.display(); // debug
-
-                colors[i] = cp.vertexOcclusion.r;
-                //colors[i3 + 1] = cp.vertexOcclusion.g;
-                //colors[i3 + 2] = cp.vertexOcclusion.b;
-
-                if ((i % 100) == 0 && i != 0)
-                {
-            CameraPane.theRenderer.setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.WAIT_CURSOR));
-                    //System.out.println("Color = " + cp.vertexOcclusion.r + ", " + cp.vertexOcclusion.g + ", " + cp.vertexOcclusion.b + "; " + (int)(100.0*i/(positions.length/3)) + "% done");
-                        System.out.println((int) (100.0 * i / (positions.length / 3)) + "% (" + i + " of " + (positions.length / 3) + ")");
-                }
-            }
-
-            this.colors = colors;
-        }
-        else
-        {
-            for (int i = 0; i < VertexCount(); i++)
-            {
-                Vertex v = GetVertex(i);
-                
-                if (v.norm == null || v.norm.x == 0 && v.norm.y == 0 && v.norm.z == 0)
-                    continue;
-
-                from.set(v.x, v.y, v.z);
-                to.set(v.x+v.norm.x, v.y+v.norm.y, v.z+v.norm.z);
-                LA.xformPos(from, transform, from);
-                LA.xformPos(to, transform, to); // RIGID ONLY
-                localcamera.setAim(from, to);
-
-                CameraPane.occlusionbuffer.display();
-
-                if (CameraPane.DEBUG_OCCLUSION)
-                    cp.display(); // debug
-
-                v.AO = cp.vertexOcclusion.r;
-
-                if ((i % 100) == 0 && i != 0)
-                {
-            CameraPane.theRenderer.setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.WAIT_CURSOR));
-                    //System.out.println("Color = " + cp.vertexOcclusion.r + ", " + cp.vertexOcclusion.g + ", " + cp.vertexOcclusion.b + "; " + (int)(100.0*i/(positions.length/3)) + "% done");
-                        System.out.println((int) (100.0 * i / VertexCount()) + "% (" + i + " of " + VertexCount() + ")");
-                }
-            }
-        }
-
-        //System.out.println("done.");
-
-        cp.renderCamera = keep;
+                cp.PrepOcclusion(this, transform);
         
         AOdone = true;
     }
@@ -7633,7 +7704,7 @@
             s3 = new cVector();
         }
         
-        CameraPane.theRenderer.setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.WAIT_CURSOR));
+        Globals.theRenderer.setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.WAIT_CURSOR));
         
         try
         {
@@ -7728,7 +7799,7 @@
         {
             if (i++%100 == 0)
             {
-                CameraPane.theRenderer.setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.WAIT_CURSOR));
+                Globals.theRenderer.setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.WAIT_CURSOR));
                 System.out.println("#faces = " + faces.size());
             //    if (i != 1)
             //        break;
@@ -7772,7 +7843,7 @@
         //Trim(true,cJME.gennormals,true,false); // doesn't work
         Trim(true,false,false,false,false);
         
-        CameraPane.theRenderer.setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.DEFAULT_CURSOR));
+        Globals.theRenderer.setCursor(java.awt.Cursor.getPredefinedCursor(java.awt.Cursor.DEFAULT_CURSOR));
     }
     
     void UpdateIndices(Face face, Face minface)
@@ -8354,9 +8425,6 @@
         return "trim = " + trimmed + "; stripped = " + stripified + "; colors = " + colors + "; faces = " + (faces!=null?faces.size():null) + "; triangles = " + (triangles!=null?triangles.length:null) + "; indices = " + indices;
     }
     
-    static Camera localcamera = new Camera();
-    static cVector from = new cVector();
-    static cVector to = new cVector();
     boolean trimmed = false;
     boolean stripified = false;
     transient boolean AOdone = false;
@@ -8364,8 +8432,10 @@
     /*transient*/ int maxIndexV = 0;
     /*transient*/ int bufV, bufF;
     // Raw version
-    private float[] positions;
-    private float[] normals;
+    //private
+            float[] positions;
+    //private
+            float[] normals;
     float[] colors;
     private float[] uvmap;
     private int[] triangles;

--
Gitblit v1.6.2