Fix faces rendering bugs

Wydzials · Wydzials · commit e08a3936ab73 · 2021-04-18T14:11:55.000+02:00
diff --git a/data/long.json b/data/long.json
@@ -0,0 +1,37 @@
+[
+  {
+    "x": -4000,
+    "y": -1000,
+    "z": 3000,
+    "xLen": 2000,
+    "yLen": 2000,
+    "zLen": 2000
+  },
+
+  {
+    "x": -4000,
+    "y": -1000,
+    "z": 6000,
+    "xLen": 2000,
+    "yLen": 2000,
+    "zLen": 2000
+  },
+
+  {
+    "x": 7000,
+    "y": -1000,
+    "z": 3000,
+    "xLen": 2000,
+    "yLen": 2000,
+    "zLen": 12000
+  },
+
+  {
+    "x": 4000,
+    "y": -1000,
+    "z": 6000,
+    "xLen": 2000,
+    "yLen": 2000,
+    "zLen": 2000
+  }
+]
diff --git a/src/pl/wydzials/virtualcamera/Sketch.java b/src/pl/wydzials/virtualcamera/Sketch.java
@@ -33,7 +33,7 @@ public class Sketch extends PApplet {
     double zRotation = 0;
 
     public void settings() {
-        size(1400, 800);
+        size(1700, 900);
     }
 
     public void setup() {
@@ -42,10 +42,31 @@ public void setup() {
 
         ModelCreator creator = new ModelCreator();
         creator.readCubesFromFile("data/model.json");
-//        creator.generateRandomCubes(100);
+        creator.generateRandomCubes(100);
         model = creator.getModel();
 
         facesTree = BinarySearchPartitioning.buildTree(model.getFaces());
+
+        updatePointsFromTree(facesTree);
+    }
+
+    private void updatePointsFromTree(TreeNode<Face> faces) {
+        if (faces == null) {
+            return;
+        }
+        Face face = faces.key;
+
+        updatePointsFromTree(faces.left);
+        for (int i = 0; i < face.getPoints().length; i++) {
+            Point point = face.getPoint(i);
+
+            if (!model.getPoints().containsKey(point.key())) {
+                model.getPoints().put(point.key(), point);
+            } else {
+                face.setPoint(i, model.getPoints().get(point.key()));
+            }
+        }
+        updatePointsFromTree(faces.right);
     }
 
     public void draw() {
@@ -54,13 +75,9 @@ public void draw() {
 
             updateSpeedFromFramerate();
             updateFocalLength();
-
             updatePoints();
-            projectLines();
 
             renderFaces(facesTree);
-            //renderLines();
-            renderText();
         }
     }
 
@@ -97,30 +114,20 @@ private Point projectPoint(Point point) {
         return new Point(x, y, z);
     }
 
-    private void projectLines() {
-        projectedLines.clear();
+    private void renderLines() {
+        strokeCap(ROUND);
+        stroke(0, 0, 0);
         for (Line line : model.getLines()) {
             if (areVisible(line.point1) && areVisible(line.point2)) {
                 Point p1 = projectPoint(line.point1);
                 Point p2 = projectPoint(line.point2);
 
-                projectedLines.add(new Line(p1, p2));
+                strokeWeight(2);
+                line((float) p1.x, (float) p1.y, (float) p2.x, (float) p2.y);
             }
         }
     }
 
-    private void renderLines() {
-        strokeCap(ROUND);
-        stroke(0, 0, 0);
-        for (Line line : projectedLines) {
-            Point p1 = line.point1;
-            Point p2 = line.point2;
-
-            strokeWeight(2);
-            line((float) p1.x, (float) p1.y, (float) p2.x, (float) p2.y);
-        }
-    }
-
     private void renderFaces(TreeNode<Face> tree) {
         if (tree == null) {
             return;
@@ -161,8 +168,9 @@ private void renderFace(Face face) {
                 quadPoints[2 * n + 1] = (float) projected.y;
             }
 
-            noStroke();
+            stroke(face.getColor().getRed(), face.getColor().getBlue(), face.getColor().getGreen());
             fill(face.getColor().getRed(), face.getColor().getBlue(), face.getColor().getGreen());
+
             quad(quadPoints[0], quadPoints[1], quadPoints[2], quadPoints[3],
                     quadPoints[4], quadPoints[5], quadPoints[6], quadPoints[7]);
         }
diff --git a/src/pl/wydzials/virtualcamera/bsp/BinarySearchPartitioning.java b/src/pl/wydzials/virtualcamera/bsp/BinarySearchPartitioning.java
@@ -47,6 +47,8 @@ private static void recursiveBuild(TreeNode<Face> tree, Set<Face> faces) {
                         secSidePoint[secCount++] = singlePoint;
                 }
                 Face[] dividedFace = Geometry.divideFace(firstSidePoint, secSidePoint, planeIndexes);
+                dividedFace[0].setColor(face.getColor());
+                dividedFace[1].setColor(face.getColor());
                 right.add(dividedFace[0]);
                 left.add(dividedFace[1]);
             }
diff --git a/src/pl/wydzials/virtualcamera/bsp/Geometry.java b/src/pl/wydzials/virtualcamera/bsp/Geometry.java
@@ -18,7 +18,6 @@ public static void main(String[] args) {
         double[] planeIndexes = calcThePlane(pointArr);
         Point pointD = new Point(1, -5, 1);
         Point pointE = new Point(2, -5, 1);
-//        Point pointE = new Point(-6.29,1.07,-3.2);
 
         int sideDecision = areTwoPointsSameSide(pointD, pointE, planeIndexes);
         if (sideDecision == -1)
@@ -27,7 +26,6 @@ else if (sideDecision == 1)
             System.out.println("Są po tej samej stronie");
         else
             System.out.println("Jeden z punktów leży na płaszczyźnie");
-
     }
 
     public static double[] calcThePlane(List<Point> points) {
@@ -51,7 +49,7 @@ public static int areTwoPointsSameSide(Point firstPoint, Point secPoint, double[
         double firstValue = firstPoint.x * planeIndexes[0] + firstPoint.y * planeIndexes[1] + firstPoint.z * planeIndexes[2] + planeIndexes[3];
         double secValue = secPoint.x * planeIndexes[0] + secPoint.y * planeIndexes[1] + secPoint.z * planeIndexes[2] + planeIndexes[3];
 
-        if (java.lang.Math.abs(firstValue) < 10 || java.lang.Math.abs(secValue) < 10) {
+        if (Math.abs(firstValue) < 10 || Math.abs(secValue) < 10) {
             return 0;
         }
         if (firstValue * secValue > 0) {
@@ -71,13 +69,13 @@ public static int areFaceAndPointSameSide(Face face, Point point, double[] plane
         long zeroCount = Arrays.stream(sameSides).filter(i -> i == 0).count();
 
         if (zeroCount == 4) {
-            return 0; // w plaszczyznie
+            return 0;
         } else if (sameCount == 4 || (zeroCount > 0 && sameCount > oppositeCount)) {
             return 1;
         } else if (oppositeCount == 4 || (zeroCount > 0 && oppositeCount > sameCount)) {
             return -1;
         } else {
-            return -10; // do podzialu
+            return -10;
         }
     }
 
@@ -86,12 +84,16 @@ public static Face[] divideFace(Point[] oneSidePoints, Point[] secSidePoints, do
         Point firstPoint = findPoint(orderedPoints[0], orderedPoints[1], planeIndexes);
         Point secPoint = findPoint(orderedPoints[2], orderedPoints[3], planeIndexes);
 
-        System.out.println("Pierwsza ściana: " + oneSidePoints[0] + " " + oneSidePoints[1] + " " + secPoint + " " + firstPoint);
-        System.out.println("Druga ściana: " + secSidePoints[0] + " " + secSidePoints[1] + " " + secPoint + " " + firstPoint);
-        System.out.println();
+        Face firstFace = new Face(oneSidePoints[0], oneSidePoints[1], firstPoint, secPoint);
+        Face secFace = new Face(secSidePoints[0], secSidePoints[1], firstPoint, secPoint);
+
+        if (pointsDistance(oneSidePoints[1], secPoint) < pointsDistance(oneSidePoints[1], firstPoint)) {
+            firstFace = new Face(oneSidePoints[0], oneSidePoints[1], secPoint, firstPoint);
+        }
+        if (pointsDistance(secSidePoints[1], secPoint) < pointsDistance(secSidePoints[1], firstPoint)) {
+            secFace = new Face(secSidePoints[0], secSidePoints[1], secPoint, firstPoint);
+        }
 
-        Face firstFace = new Face(oneSidePoints[0], oneSidePoints[1], secPoint, firstPoint);
-        Face secFace = new Face(secSidePoints[0], secSidePoints[1], secPoint, firstPoint);
         return new Face[]{firstFace, secFace};
     }
 
@@ -107,8 +109,8 @@ private static Point findPoint(Point firstPoint, Point secPoint, double[] planeI
     private static Point[] determinePointPairs(Point[] oneSidePoints, Point[] secSidePoints) {
         double[] firstVector = calculateVector(oneSidePoints[0], secSidePoints[0]);
         double[] secVector = calculateVector(oneSidePoints[0], secSidePoints[1]);
-        double firstVectorLength = java.lang.Math.sqrt(firstVector[0] * firstVector[0] + firstVector[1] * firstVector[1] + firstVector[2] * firstVector[2]);
-        double secVectorLength = java.lang.Math.sqrt(secVector[0] * secVector[0] + secVector[1] * secVector[1] + secVector[2] * secVector[2]);
+        double firstVectorLength = Math.sqrt(firstVector[0] * firstVector[0] + firstVector[1] * firstVector[1] + firstVector[2] * firstVector[2]);
+        double secVectorLength = Math.sqrt(secVector[0] * secVector[0] + secVector[1] * secVector[1] + secVector[2] * secVector[2]);
 
         if (firstVectorLength < secVectorLength) {
             return new Point[]{oneSidePoints[0], secSidePoints[0], oneSidePoints[1], secSidePoints[1]};
@@ -119,4 +121,9 @@ private static Point[] determinePointPairs(Point[] oneSidePoints, Point[] secSid
     private static double[] calculateVector(Point firstPoint, Point secPoint) {
         return new double[]{firstPoint.x - secPoint.x, firstPoint.y - secPoint.y, firstPoint.z - secPoint.z};
     }
+
+    private static double pointsDistance(Point a, Point b) {
+        double[] vector = calculateVector(a, b);
+        return Math.sqrt(Arrays.stream(vector).map(v -> v * v).sum());
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -47,6 +47,8 @@ private static void recursiveBuild(TreeNode<Face> tree, Set<Face> faces) {`
`47`	`47`	`secSidePoint[secCount++] = singlePoint;`
`48`	`48`	`}`
`49`	`49`	`Face[] dividedFace = Geometry.divideFace(firstSidePoint, secSidePoint, planeIndexes);`
	`50`	`+ dividedFace[0].setColor(face.getColor());`
	`51`	`+ dividedFace[1].setColor(face.getColor());`
`50`	`52`	`right.add(dividedFace[0]);`
`51`	`53`	`left.add(dividedFace[1]);`
`52`	`54`	`}`