Node.java

Go to the documentation of this file.

 
package eu.mihosoft.vrl.v3d;
 
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
// TODO: Auto-generated Javadoc
final class Node {
 
    private List<Polygon> polygons;
    private Plane plane;
    private Node front;
    private Node back;
    
    private long maxDepth = -1;
 
    public Node(List<Polygon> polygons) {
        this.polygons = new ArrayList<>();
        if (polygons != null) {
            this.build(polygons);
        }
    }
 
    public Node() {
        this(null);
    }
 
    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Object#clone()
     */
    @Override
    public Node clone() {
        Node node = new Node();
        node.plane = this.plane == null ? null : this.plane.clone();
        node.front = this.front == null ? null : this.front.clone();
        node.back = this.back == null ? null : this.back.clone();
//        node.polygons = new ArrayList<>();
//        polygons.parallelStream().forEach((Polygon p) -> {
//            node.polygons.add(p.clone());
//        });
 
        Stream<Polygon> polygonStream;
 
        if (polygons.size() > 200) {
            polygonStream = polygons.parallelStream();
        } else 
        polygonStream = polygons.stream();
 
        node.polygons = polygonStream.map(p -> p.clone()).collect(Collectors.toList());
 
        return node;
    }
 
    public void invert() {
 
        Stream<Polygon> polygonStream;
 
        if (polygons.size() > 200) {
            polygonStream = polygons.parallelStream();
        } else 
        polygonStream = polygons.stream();
 
        polygonStream.forEach((polygon) -> {
            polygon.flip();
        });
 
        if (this.plane == null && !polygons.isEmpty()) {
            this.plane = polygons.get(0).plane.clone();
        } else if (this.plane == null && polygons.isEmpty()) {
 
            //System.err.println("Please fix me! I don't know what to do?");
            throw new RuntimeException("Please fix me! I don't know what to do?");
            // return;
        }
 
        this.plane.flip();
 
        if (this.front != null) {
            this.front.invert();
        }
        if (this.back != null) {
            this.back.invert();
        }
        Node temp = this.front;
        this.front = this.back;
        this.back = temp;
    }
 
    private List<Polygon> clipPolygons(List<Polygon> polygons) {
 
        if (this.plane == null) {
            return new ArrayList<>(polygons);
        }
 
        List<Polygon> frontP = new ArrayList<>();
        List<Polygon> backP = new ArrayList<>();
 
        for (Polygon polygon : polygons) {
            this.plane.splitPolygon(polygon, frontP, backP, frontP, backP);
        }
        if (this.front != null) {
            frontP = this.front.clipPolygons(frontP);
        }
        if (this.back != null) {
            backP = this.back.clipPolygons(backP);
        } else {
            backP = new ArrayList<>(0);
        }
 
        frontP.addAll(backP);
        return frontP;
    }
 
    // Remove all polygons in this BSP tree that are inside the other BSP tree
    // `bsp`.
    public void clipTo(Node bsp) {
        this.polygons = bsp.clipPolygons(this.polygons);
        if (this.front != null) {
            this.front.clipTo(bsp);
        }
        if (this.back != null) {
            this.back.clipTo(bsp);
        }
    }
 
    public List<Polygon> allPolygons() {
        List<Polygon> localPolygons = new ArrayList<>(this.polygons);
        if (this.front != null) {
            localPolygons.addAll(this.front.allPolygons());
//            polygons = Utils.concat(polygons, this.front.allPolygons());
        }
        if (this.back != null) {
//            polygons = Utils.concat(polygons, this.back.allPolygons());
            localPolygons.addAll(this.back.allPolygons());
        }
 
        return localPolygons;
    }
 
    public final void build(List<Polygon> polygons) {
        build(polygons, 0,polygons.size() );
    }
 
    public final void build(List<Polygon> polygons, long depth, long maxDepth) {
//      if (depth > maxDepth) {
//          throw new RuntimeException("Impossible Node depth " + depth + " with " + polygons.size() + " remaining max = "+maxDepth );
//      }
//      if (depth > 200) {
//          System.out.println("Node depth " + depth + " with " + polygons.size() + " remaining ");
//          Plane.setUseDebugger(true);
//      } else {
//          Plane.setUseDebugger(false);
//      }
 
        if (polygons.isEmpty()) {
 
            return;
        }
 
        if (this.plane == null) {
            this.plane = polygons.get(0).plane.clone();
        }
        //this.polygons.add(polygons.get(0));
 
        List<Polygon> frontP = new ArrayList<>();
        List<Polygon> backP = new ArrayList<>();
 
        // parellel version does not work here
        for(int i=0;i<polygons.size();i++) {
            this.plane.splitPolygon(polygons.get(i), this.polygons, this.polygons, frontP, backP);
        }
        if (frontP.size() > 0) {
            if (this.front == null) {
                this.front = new Node();
            }
            this.front.build(frontP, depth + 1,maxDepth);
        }
        if (backP.size() > 0) {
            if (this.back == null) {
                this.back = new Node();
            }
            this.back.build(backP, depth + 1,maxDepth);
        }
    }
}