commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/OBJWriter.java - commons-geometry - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.apache.commons.geometry.euclidean.threed;

 import java.io.File;
 import java.io.IOException;
 import java.io.Writer;
 import java.nio.file.Files;
 import java.text.DecimalFormat;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;

 import org.apache.commons.geometry.core.partitioning.BSPTree;
 import org.apache.commons.geometry.core.partitioning.BSPTreeVisitor;
 import org.apache.commons.geometry.core.partitioning.BoundaryAttribute;
 import org.apache.commons.geometry.core.precision.DoublePrecisionContext;
 import org.apache.commons.geometry.euclidean.twod.PolygonsSet;
 import org.apache.commons.geometry.euclidean.twod.Vector2D;

 /** This class creates simple OBJ files from {@link PolyhedronsSet} instances.
  * The output files can be opened in a 3D viewer for visual debugging of 3D
  * regions. This class is only intended for use in testing.
  *
  * @see https://en.wikipedia.org/wiki/Wavefront_.obj_file
  */
 public class OBJWriter {

     /** Writes an OBJ file representing the given {@link PolyhedronsSet}. Only
      * finite boundaries are written. Infinite boundaries are ignored.
      * @param file The path of the file to write
      * @param poly The input PolyhedronsSet
      * @throws IOException
      */
     public static void write(String file, PolyhedronsSet poly) throws IOException {
         write(new File(file), poly);
     }

     /** Writes an OBJ file representing the given {@link PolyhedronsSet}. Only
      * finite boundaries are written. Infinite boundaries are ignored.
      * @param file The file to write
      * @param poly The input PolyhedronsSet
      * @throws IOException
      */
     public static void write(File file, PolyhedronsSet poly) throws IOException {
         // get the vertices and faces
         MeshBuilder meshBuilder = new MeshBuilder(poly.getPrecision());
         poly.getTree(true).visit(meshBuilder);

         // write them to the file
         try (Writer writer = Files.newBufferedWriter(file.toPath())) {
             writer.write("# Generated by " + OBJWriter.class.getName() + " on " + new Date() + "\n");
             writeVertices(writer, meshBuilder.getVertices());
             writeFaces(writer, meshBuilder.getFaces());
         }
     }

     /** Writes the given list of vertices to the file in the OBJ format.
      * @param writer
      * @param vertices
      * @throws IOException
      */
     private static void writeVertices(Writer writer, List<Vector3D> vertices) throws IOException {
         DecimalFormat df = new DecimalFormat("0.######");

         for (Vector3D v : vertices) {
             writer.write("v ");
             writer.write(df.format(v.getX()));
             writer.write(" ");
             writer.write(df.format(v.getY()));
             writer.write(" ");
             writer.write(df.format(v.getZ()));
             writer.write("\n");
         }
     }

     /** Writes the given list of face vertex indices to the file in the OBJ format. The indices
      * are expected to be 0-based and are converted to the 1-based format used by OBJ.
      * @param writer
      * @param faces
      * @throws IOException
      */
     private static void writeFaces(Writer writer, List<int[]> faces) throws IOException {
         for (int[] face : faces) {
             writer.write("f ");
             for (int idx : face) {
                 writer.write(String.valueOf(idx + 1)); // obj indices are 1-based
                 writer.write(" ");
             }
             writer.write("\n");
         }
     }

     /** Class used to impose a strict sorting on 3D vertices.
      * If all of the components of two vertices are within tolerance of each
      * other, then the vertices are considered equal. This helps to avoid
      * writing duplicate vertices in the OBJ output.
      */
     private static class VertexComparator implements Comparator<Vector3D> {

         /** Precision context to deteremine floating-point equality */
         private final DoublePrecisionContext precision;

         /** Creates a new instance with the given tolerance value.
          * @param tolerance
          */
         public VertexComparator(final DoublePrecisionContext precision) {
             this.precision = precision;
         }

         /** {@inheritDoc} */
         @Override
         public int compare(Vector3D a, Vector3D b) {
             int result = precision.compare(a.getX(), b.getX());
             if (result == 0) {
                 result = precision.compare(a.getY(), b.getY());
                 if (result == 0) {
                     result = precision.compare(a.getZ(), b.getZ());
                 }
             }
             return result;
         }
     }

     /** Class for converting a 3D BSPTree into a list of vertices
      * and face vertex indices.
      */
     private static class MeshBuilder implements BSPTreeVisitor<Vector3D> {

         /** Precision context to deteremine floating-point equality */
         private final DoublePrecisionContext precision;

         /** Map of vertices to their index in the vertices list */
         private Map<Vector3D, Integer> vertexIndexMap;

         /** List of unique vertices in the BSPTree boundary */
         private List<Vector3D> vertices;

         /**
          * List of face vertex indices. Each face will have 3 indices. Indices
          * are 0-based.
          * */
         private List<int[]> faces;

         /** Creates a new instance with the given tolerance.
          * @param tolerance
          */
         public MeshBuilder(final DoublePrecisionContext precision) {
             this.precision = precision;
             this.vertexIndexMap = new TreeMap<>(new VertexComparator(precision));
             this.vertices = new ArrayList<>();
             this.faces = new ArrayList<>();
         }

         /** Returns the list of unique vertices found in the BSPTree.
          * @return
          */
         public List<Vector3D> getVertices() {
             return vertices;
         }

         /** Returns the list of 0-based face vertex indices for the BSPTree. Each face is
          * a triangle with 3 indices.
          * @return
          */
         public List<int[]> getFaces() {
             return faces;
         }

         /** {@inheritDoc} */
         @Override
         public Order visitOrder(BSPTree<Vector3D> node) {
             return Order.SUB_MINUS_PLUS;
         }

         /** {@inheritDoc} */
         @SuppressWarnings("unchecked")
         @Override
         public void visitInternalNode(BSPTree<Vector3D> node) {
             BoundaryAttribute<Vector3D> attr = (BoundaryAttribute<Vector3D>) node.getAttribute();

             if (attr.getPlusOutside() != null) {
                 addBoundary((SubPlane) attr.getPlusOutside());
             }
             else if (attr.getPlusInside() != null) {
                 addBoundary((SubPlane) attr.getPlusInside());
             }
         }

         /** {@inheritDoc} */
         @Override
         public void visitLeafNode(BSPTree<Vector3D> node) {
             // do nothing
         }

         /** Adds the region boundary defined by the given {@link SubPlane}
          * to the mesh.
          * @param subplane
          */
         private void addBoundary(SubPlane subplane) {
             Plane plane = (Plane) subplane.getHyperplane();
             PolygonsSet poly = (PolygonsSet) subplane.getRemainingRegion();

             TriangleExtractor triExtractor = new TriangleExtractor(precision);
             poly.getTree(true).visit(triExtractor);

             Vector3D v1, v2, v3;
             for (Vector2D[] tri : triExtractor.getTriangles()) {
                 v1 = plane.toSpace(tri[0]);
                 v2 = plane.toSpace(tri[1]);
                 v3 = plane.toSpace(tri[2]);

                 faces.add(new int[] {
                         getVertexIndex(v1),
                         getVertexIndex(v2),
                         getVertexIndex(v3)
                 });
             }
         }

         /** Returns the 0-based index of the given vertex in the <code>vertices</code>
          * list. If the vertex has not been encountered before, it is added
          * to the list.
          * @param vertex
          * @return
          */
         private int getVertexIndex(Vector3D vertex) {
             Integer idx = vertexIndexMap.get(vertex);
             if (idx == null) {
                 idx = vertices.size();

                 vertices.add(vertex);
                 vertexIndexMap.put(vertex, idx);
             }
             return idx.intValue();
         }
     }

     /** Visitor for extracting a collection of triangles from a 2D BSPTree.
      */
     private static class TriangleExtractor implements BSPTreeVisitor<Vector2D> {

         /** Precision context to deteremine floating-point equality */
         private final DoublePrecisionContext precision;

         /** List of extracted triangles */
         private List<Vector2D[]> triangles = new ArrayList<>();

         /** Creates a new instance with the given geometric tolerance.
          * @param tolerance
          */
         public TriangleExtractor(final DoublePrecisionContext precision) {
             this.precision = precision;
         }

         /** Returns the list of extracted triangles.
          * @return
          */
         public List<Vector2D[]> getTriangles() {
             return triangles;
         }

         /** {@inheritDoc} */
         @Override
         public Order visitOrder(BSPTree<Vector2D> node) {
             return Order.SUB_MINUS_PLUS;
         }

         /** {@inheritDoc} */
         @Override
         public void visitInternalNode(BSPTree<Vector2D> node) {
             // do nothing
         }

         /** {@inheritDoc} */
         @Override
         public void visitLeafNode(BSPTree<Vector2D> node) {
             if ((Boolean) node.getAttribute()) {
                 PolygonsSet convexPoly = new PolygonsSet(node.pruneAroundConvexCell(Boolean.TRUE,
                         Boolean.FALSE, null), precision);

                 for (Vector2D[] loop : convexPoly.getVertices()) {
                     if (loop.length > 0 && loop[0] != null) { // skip unclosed loops
                         addTriangles(loop);
                     }
                 }
             }
         }

         /** Splits the 2D convex area defined by the given vertices into
          * triangles and adds them to the internal list.
          * @param vertices
          */
         private void addTriangles(Vector2D[] vertices) {
             // use a triangle fan to add the convex region
             for (int i=2; i<vertices.length; ++i) {
                 triangles.add(new Vector2D[] { vertices[0], vertices[i-1], vertices[i] });
             }
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package org.apache.commons.geometry.euclidean.threed;

	import java.io.File;
	import java.io.IOException;
	import java.io.Writer;
	import java.nio.file.Files;
	import java.text.DecimalFormat;
	import java.util.ArrayList;
	import java.util.Comparator;
	import java.util.Date;
	import java.util.List;
	import java.util.Map;
	import java.util.TreeMap;

	import org.apache.commons.geometry.core.partitioning.BSPTree;
	import org.apache.commons.geometry.core.partitioning.BSPTreeVisitor;
	import org.apache.commons.geometry.core.partitioning.BoundaryAttribute;
	import org.apache.commons.geometry.core.precision.DoublePrecisionContext;
	import org.apache.commons.geometry.euclidean.twod.PolygonsSet;
	import org.apache.commons.geometry.euclidean.twod.Vector2D;

	/** This class creates simple OBJ files from {@link PolyhedronsSet} instances.
	* The output files can be opened in a 3D viewer for visual debugging of 3D
	* regions. This class is only intended for use in testing.
	*
	* @see https://en.wikipedia.org/wiki/Wavefront_.obj_file
	*/
	public class OBJWriter {

	/** Writes an OBJ file representing the given {@link PolyhedronsSet}. Only
	* finite boundaries are written. Infinite boundaries are ignored.
	* @param file The path of the file to write
	* @param poly The input PolyhedronsSet
	* @throws IOException
	*/
	public static void write(String file, PolyhedronsSet poly) throws IOException {
	write(new File(file), poly);
	}

	/** Writes an OBJ file representing the given {@link PolyhedronsSet}. Only
	* finite boundaries are written. Infinite boundaries are ignored.
	* @param file The file to write
	* @param poly The input PolyhedronsSet
	* @throws IOException
	*/
	public static void write(File file, PolyhedronsSet poly) throws IOException {
	// get the vertices and faces
	MeshBuilder meshBuilder = new MeshBuilder(poly.getPrecision());
	poly.getTree(true).visit(meshBuilder);

	// write them to the file
	try (Writer writer = Files.newBufferedWriter(file.toPath())) {
	writer.write("# Generated by " + OBJWriter.class.getName() + " on " + new Date() + "\n");
	writeVertices(writer, meshBuilder.getVertices());
	writeFaces(writer, meshBuilder.getFaces());
	}
	}

	/** Writes the given list of vertices to the file in the OBJ format.
	* @param writer
	* @param vertices
	* @throws IOException
	*/
	private static void writeVertices(Writer writer, List<Vector3D> vertices) throws IOException {
	DecimalFormat df = new DecimalFormat("0.######");

	for (Vector3D v : vertices) {
	writer.write("v ");
	writer.write(df.format(v.getX()));
	writer.write(" ");
	writer.write(df.format(v.getY()));
	writer.write(" ");
	writer.write(df.format(v.getZ()));
	writer.write("\n");
	}
	}

	/** Writes the given list of face vertex indices to the file in the OBJ format. The indices
	* are expected to be 0-based and are converted to the 1-based format used by OBJ.
	* @param writer
	* @param faces
	* @throws IOException
	*/
	private static void writeFaces(Writer writer, List<int[]> faces) throws IOException {
	for (int[] face : faces) {
	writer.write("f ");
	for (int idx : face) {
	writer.write(String.valueOf(idx + 1)); // obj indices are 1-based
	writer.write(" ");
	}
	writer.write("\n");
	}
	}

	/** Class used to impose a strict sorting on 3D vertices.
	* If all of the components of two vertices are within tolerance of each
	* other, then the vertices are considered equal. This helps to avoid
	* writing duplicate vertices in the OBJ output.
	*/
	private static class VertexComparator implements Comparator<Vector3D> {

	/** Precision context to deteremine floating-point equality */
	private final DoublePrecisionContext precision;

	/** Creates a new instance with the given tolerance value.
	* @param tolerance
	*/
	public VertexComparator(final DoublePrecisionContext precision) {
	this.precision = precision;
	}

	/** {@inheritDoc} */
	@Override
	public int compare(Vector3D a, Vector3D b) {
	int result = precision.compare(a.getX(), b.getX());
	if (result == 0) {
	result = precision.compare(a.getY(), b.getY());
	if (result == 0) {
	result = precision.compare(a.getZ(), b.getZ());
	}
	}
	return result;
	}
	}

	/** Class for converting a 3D BSPTree into a list of vertices
	* and face vertex indices.
	*/
	private static class MeshBuilder implements BSPTreeVisitor<Vector3D> {

	/** Precision context to deteremine floating-point equality */
	private final DoublePrecisionContext precision;

	/** Map of vertices to their index in the vertices list */
	private Map<Vector3D, Integer> vertexIndexMap;

	/** List of unique vertices in the BSPTree boundary */
	private List<Vector3D> vertices;

	/**
	* List of face vertex indices. Each face will have 3 indices. Indices
	* are 0-based.
	* */
	private List<int[]> faces;

	/** Creates a new instance with the given tolerance.
	* @param tolerance
	*/
	public MeshBuilder(final DoublePrecisionContext precision) {
	this.precision = precision;
	this.vertexIndexMap = new TreeMap<>(new VertexComparator(precision));
	this.vertices = new ArrayList<>();
	this.faces = new ArrayList<>();
	}

	/** Returns the list of unique vertices found in the BSPTree.
	* @return
	*/
	public List<Vector3D> getVertices() {
	return vertices;
	}

	/** Returns the list of 0-based face vertex indices for the BSPTree. Each face is
	* a triangle with 3 indices.
	* @return
	*/
	public List<int[]> getFaces() {
	return faces;
	}

	/** {@inheritDoc} */
	@Override
	public Order visitOrder(BSPTree<Vector3D> node) {
	return Order.SUB_MINUS_PLUS;
	}

	/** {@inheritDoc} */
	@SuppressWarnings("unchecked")
	@Override
	public void visitInternalNode(BSPTree<Vector3D> node) {
	BoundaryAttribute<Vector3D> attr = (BoundaryAttribute<Vector3D>) node.getAttribute();

	if (attr.getPlusOutside() != null) {
	addBoundary((SubPlane) attr.getPlusOutside());
	}
	else if (attr.getPlusInside() != null) {
	addBoundary((SubPlane) attr.getPlusInside());
	}
	}

	/** {@inheritDoc} */
	@Override
	public void visitLeafNode(BSPTree<Vector3D> node) {
	// do nothing
	}

	/** Adds the region boundary defined by the given {@link SubPlane}
	* to the mesh.
	* @param subplane
	*/
	private void addBoundary(SubPlane subplane) {
	Plane plane = (Plane) subplane.getHyperplane();
	PolygonsSet poly = (PolygonsSet) subplane.getRemainingRegion();

	TriangleExtractor triExtractor = new TriangleExtractor(precision);
	poly.getTree(true).visit(triExtractor);

	Vector3D v1, v2, v3;
	for (Vector2D[] tri : triExtractor.getTriangles()) {
	v1 = plane.toSpace(tri[0]);
	v2 = plane.toSpace(tri[1]);
	v3 = plane.toSpace(tri[2]);

	faces.add(new int[] {
	getVertexIndex(v1),
	getVertexIndex(v2),
	getVertexIndex(v3)
	});
	}
	}

	/** Returns the 0-based index of the given vertex in the <code>vertices</code>
	* list. If the vertex has not been encountered before, it is added
	* to the list.
	* @param vertex
	* @return
	*/
	private int getVertexIndex(Vector3D vertex) {
	Integer idx = vertexIndexMap.get(vertex);
	if (idx == null) {
	idx = vertices.size();

	vertices.add(vertex);
	vertexIndexMap.put(vertex, idx);
	}
	return idx.intValue();
	}
	}

	/** Visitor for extracting a collection of triangles from a 2D BSPTree.
	*/
	private static class TriangleExtractor implements BSPTreeVisitor<Vector2D> {

	/** Precision context to deteremine floating-point equality */
	private final DoublePrecisionContext precision;

	/** List of extracted triangles */
	private List<Vector2D[]> triangles = new ArrayList<>();

	/** Creates a new instance with the given geometric tolerance.
	* @param tolerance
	*/
	public TriangleExtractor(final DoublePrecisionContext precision) {
	this.precision = precision;
	}

	/** Returns the list of extracted triangles.
	* @return
	*/
	public List<Vector2D[]> getTriangles() {
	return triangles;
	}

	/** {@inheritDoc} */
	@Override
	public Order visitOrder(BSPTree<Vector2D> node) {
	return Order.SUB_MINUS_PLUS;
	}

	/** {@inheritDoc} */
	@Override
	public void visitInternalNode(BSPTree<Vector2D> node) {
	// do nothing
	}

	/** {@inheritDoc} */
	@Override
	public void visitLeafNode(BSPTree<Vector2D> node) {
	if ((Boolean) node.getAttribute()) {
	PolygonsSet convexPoly = new PolygonsSet(node.pruneAroundConvexCell(Boolean.TRUE,
	Boolean.FALSE, null), precision);

	for (Vector2D[] loop : convexPoly.getVertices()) {
	if (loop.length > 0 && loop[0] != null) { // skip unclosed loops
	addTriangles(loop);
	}
	}
	}
	}

	/** Splits the 2D convex area defined by the given vertices into
	* triangles and adds them to the internal list.
	* @param vertices
	*/
	private void addTriangles(Vector2D[] vertices) {
	// use a triangle fan to add the convex region
	for (int i=2; i<vertices.length; ++i) {
	triangles.add(new Vector2D[] { vertices[0], vertices[i-1], vertices[i] });
	}
	}
	}
	}