de.jreality.geometry

Class IndexedFaceSetFactory

java.lang.Object

de.jreality.geometry.AbstractGeometryFactory

de.jreality.geometry.AbstractPointSetFactory

de.jreality.geometry.AbstractIndexedLineSetFactory

de.jreality.geometry.AbstractIndexedFaceSetFactory

de.jreality.geometry.IndexedFaceSetFactory

All Implemented Interfaces:

GeometryFactory

public class IndexedFaceSetFactory
extends AbstractIndexedFaceSetFactory

This factory classes can be used to create and edit instances of IndexedFaceSet. See IndexedLineSetFactory and PointSetFactory for functionality inherited from the superclasses.

Specifying the geometry

To specify faces, first set the number of faces using setFaceCount(int). The faces themselves are specified using the method setFaceIndices(int[][]) and its variants. Each element of this array is a list of indices into the coordinate array of the underlying point set (See PointSetFactory).

Standard attributes

There are methods for setting the built-in face attributes normals, colors, and labels. Texture coordinates can have fiber length 2, 3, or 4. Normals in euclidean case must have fiber length 3; otherwise they should have length 4. Labels are represented by an array of type String[], and are displayed at the center of the face.

Generated attributes

There are a number of boolean methods to control whether the factory generates various types of derivative information:

• AbstractIndexedFaceSetFactory.setGenerateAABBTree(boolean): The AABBTree is stored as an Attribute within the geometry and is used to optimize picking.
• AbstractIndexedFaceSetFactory.setGenerateFaceLabels(boolean): The face labels show the index of the face within the face array and are displayed at the midpoint of the face.
• AbstractIndexedFaceSetFactory.setGenerateFaceNormals(boolean): The face normals are generated using the cross product of the first two edges of the face, with respect to the specified metric (see AbstractGeometryFactory.setMetric(int).
• AbstractIndexedFaceSetFactory.setGenerateVertexNormals(boolean): The vertex normals are generated based on the face normals, by averaging using the combinatorial information in the face index array.
• AbstractIndexedFaceSetFactory.setGenerateEdgesFromFaces(boolean): By default there are no edges attached to the indexed face set. Either set them explicitly using setEdgeIndices(int[]) and its variants, or call this method with true as argument; then the edge indices will be generated as the edges of the faces.

By default, all these values are false.

More Attributes

For attributes not included in the built-in set, use the methods

• setFaceAttribute(Attribute, DataList)
• setFaceAttribute(Attribute, double[])
• setFaceAttribute(Attribute, double[][])

Unwrapping

A geometry in the jReality scene graph does not allow per face vertex attributes. So to unwrap a geometry e.g. to put a texture on it, one has to introduce multiple vertices. This factory supports this as follows: set vertex coordinates for all vertices (setVertexCount(), setVertexCoordinates()), set the face indices to the wrapped faces (leave out the extra vertices) (setFaceCount(), setFaceIndices), and use setUnwrapFaceIndices(int[][]) or its variants to introduce the unwrapped faces (same number of faces).

The unwrapFaceIndices are written into the created IndexedFaceSet. The faceIndices are used to generate attributes, in particular to generate correct vertex normals. The vertices that represent the same vertex are detected from correspondence in faceIndices and unwrapFaceIndices, and not from the vertex coordinates. There is also a tutorial that explains the use of unwrapping.

Since the vertex count includes the extra vertices for unwrapping, one needs to multiply vertex attributes for the extra vertices. More often than not, one needs to copy the attributes to the corresponding vertices. The correspondence may be determined from the two sets of face indices. The method unwrapVertexAttributes() does this for you. It has a static version (which needs more parameters) and an instance version (which reads the corresponding parameters from the instance). It comes in many versions in order to be directly applicable to those vertex attributes that are flat arrays of primitives.

Author:

gunn, peters

See Also:

QuadMeshFactory,

For an example, see this tutorial

Constructor Summary

Constructors

Constructor and Description
IndexedFaceSetFactory()

Method Summary

Modifier and Type	Method and Description
void	setEdgeAttribute(Attribute attr, DataList data)
void	setEdgeAttribute(Attribute attr, double[] data)
void	setEdgeAttribute(Attribute attr, double[][] data)
void	setEdgeColors(Color[] data)
void	setEdgeColors(DataList data)
void	setEdgeColors(double[] data)
void	setEdgeColors(double[][] data)
void	setEdgeCount(int count)
void	setEdgeIndices(int[] data)
void	setEdgeIndices(int[][] data)
void	setEdgeIndices(int[] data, int pointCountPerLine)
void	setEdgeLabels(String[] data)
void	setEdgeRelativeRadii(double[] data)
void	setFaceAttribute(Attribute attr, DataList data) Superclass methods are protected so we override to make public Documentation is lacking ...
void	setFaceAttribute(Attribute attr, double[] data)
void	setFaceAttribute(Attribute attr, double[][] data)
void	setFaceAttributes(DataListSet dls)
void	setFaceColors(Color[] data)
void	setFaceColors(DataList data)
void	setFaceColors(double[] data)
void	setFaceColors(double[][] data)
void	setFaceCount(int count)
void	setFaceIndices(DataList data)
void	setFaceIndices(int[] data)
void	setFaceIndices(int[][] data)
void	setFaceIndices(int[] data, int pointCountPerFace)
void	setFaceLabels(String[] data)
void	setFaceNormals(DataList data)
void	setFaceNormals(double[] data)
void	setFaceNormals(double[][] data)
void	setUnwrapFaceIndices(DataList data)
void	setUnwrapFaceIndices(int[] data)
void	setUnwrapFaceIndices(int[][] data)
void	setUnwrapFaceIndices(int[] data, int pointCountPerFace)
void	setVertexAttribute(Attribute attr, DataList data)
void	setVertexAttribute(Attribute attr, double[] data)
void	setVertexAttribute(Attribute attr, double[][] data)
void	setVertexAttributes(DataListSet dls)
void	setVertexColors(Color[] data)
void	setVertexColors(DataList data)
void	setVertexColors(double[] data)
void	setVertexColors(double[][] data)
void	setVertexCoordinates(DataList data)
void	setVertexCoordinates(double[] data)
void	setVertexCoordinates(double[][] data)
void	setVertexCount(int count)
void	setVertexLabels(String[] data)
void	setVertexNormals(DataList data)
void	setVertexNormals(double[] data)
void	setVertexNormals(double[][] data)
void	setVertexRelativeRadii(double[] data)
void	setVertexTextureCoordinates(DataList data)
void	setVertexTextureCoordinates(double[] data)
void	setVertexTextureCoordinates(double[][] data)
boolean[]	unwrapVertexAttributes(boolean[] data, int entriesPerVertex)
static boolean[]	unwrapVertexAttributes(boolean[] data, int entriesPerVertex, int[][] faceIndices, int[][] unwrapFaceIndices, int numberOfUnwrapVertices)
char[]	unwrapVertexAttributes(char[] data, int entriesPerVertex)
static char[]	unwrapVertexAttributes(char[] data, int entriesPerVertex, int[][] faceIndices, int[][] unwrapFaceIndices, int numberOfUnwrapVertices)
double[]	unwrapVertexAttributes(double[] data, int entriesPerVertex)
static double[]	unwrapVertexAttributes(double[] data, int entriesPerVertex, int[][] faceIndices, int[][] unwrapFaceIndices, int numberOfUnwrapVertices)
<E> E[]	unwrapVertexAttributes(E[] data)
static <E> E[]	unwrapVertexAttributes(E[] data, int[][] faceIndices, int[][] unwrapFaceIndices, int numberOfUnwrapVertices)
float[]	unwrapVertexAttributes(float[] data, int entriesPerVertex)
static float[]	unwrapVertexAttributes(float[] data, int entriesPerVertex, int[][] faceIndices, int[][] unwrapFaceIndices, int numberOfUnwrapVertices)
int[]	unwrapVertexAttributes(int[] data, int entriesPerVertex)
static int[]	unwrapVertexAttributes(int[] data, int entriesPerVertex, int[][] faceIndices, int[][] unwrapFaceIndices, int numberOfUnwrapVertices)
long[]	unwrapVertexAttributes(long[] data, int entriesPerVertex)
static long[]	unwrapVertexAttributes(long[] data, int entriesPerVertex, int[][] faceIndices, int[][] unwrapFaceIndices, int numberOfUnwrapVertices)

Methods inherited from class de.jreality.geometry.AbstractIndexedFaceSetFactory

getIndexedFaceSet, isGenerateAABBTree, isGenerateEdgesFromFaces, isGenerateFaceLabels, isGenerateFaceNormals, isGenerateVertexNormals, setGenerateAABBTree, setGenerateEdgesFromFaces, setGenerateFaceLabels, setGenerateFaceNormals, setGenerateVertexNormals

Methods inherited from class de.jreality.geometry.AbstractIndexedLineSetFactory

getEdgeCount, getIndexedLineSet, getLineCount, isGenerateEdgeLabels, setGenerateEdgeLabels, setLineCount

Methods inherited from class de.jreality.geometry.AbstractPointSetFactory

getPointSet, getVertexCount, isGenerateVertexLabels, setGenerateVertexLabels

Methods inherited from class de.jreality.geometry.AbstractGeometryFactory

getGeometry, getMetric, setMetric, update

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

IndexedFaceSetFactory

public IndexedFaceSetFactory()

Method Detail

setVertexCount

public void setVertexCount(int count)

Overrides:

setVertexCount in class AbstractPointSetFactory

setVertexAttribute

public void setVertexAttribute(Attribute attr,
                               DataList data)

setVertexAttribute

public void setVertexAttribute(Attribute attr,
                               double[] data)

setVertexAttribute

public void setVertexAttribute(Attribute attr,
                               double[][] data)

Overrides:

setVertexAttribute in class AbstractPointSetFactory

setVertexAttributes

public void setVertexAttributes(DataListSet dls)

setVertexCoordinates

public void setVertexCoordinates(DataList data)

setVertexCoordinates

public void setVertexCoordinates(double[] data)

setVertexCoordinates

public void setVertexCoordinates(double[][] data)

setVertexNormals

public void setVertexNormals(DataList data)

setVertexNormals

public void setVertexNormals(double[] data)

setVertexNormals

public void setVertexNormals(double[][] data)

setVertexColors

public void setVertexColors(DataList data)

setVertexColors

public void setVertexColors(double[] data)

setVertexColors

public void setVertexColors(Color[] data)

setVertexColors

public void setVertexColors(double[][] data)

setVertexTextureCoordinates

public void setVertexTextureCoordinates(DataList data)

setVertexTextureCoordinates

public void setVertexTextureCoordinates(double[] data)

setVertexTextureCoordinates

public void setVertexTextureCoordinates(double[][] data)

setVertexLabels

public void setVertexLabels(String[] data)

setVertexRelativeRadii

public void setVertexRelativeRadii(double[] data)

setEdgeCount

public void setEdgeCount(int count)

setEdgeAttribute

public void setEdgeAttribute(Attribute attr,
                             DataList data)

setEdgeAttribute

public void setEdgeAttribute(Attribute attr,
                             double[] data)

setEdgeAttribute

public void setEdgeAttribute(Attribute attr,
                             double[][] data)

setEdgeIndices

public void setEdgeIndices(int[][] data)

setEdgeIndices

public void setEdgeIndices(int[] data,
                           int pointCountPerLine)

setEdgeIndices

public void setEdgeIndices(int[] data)

setEdgeColors

public void setEdgeColors(DataList data)

setEdgeColors

public void setEdgeColors(double[] data)

setEdgeColors

public void setEdgeColors(Color[] data)

setEdgeColors

public void setEdgeColors(double[][] data)

setEdgeLabels

public void setEdgeLabels(String[] data)

setEdgeRelativeRadii

public void setEdgeRelativeRadii(double[] data)

setFaceCount

public void setFaceCount(int count)

setFaceAttribute

public void setFaceAttribute(Attribute attr,
                             DataList data)

Superclass methods are protected so we override to make public Documentation is lacking ...

setFaceAttribute

public void setFaceAttribute(Attribute attr,
                             double[] data)

setFaceAttribute

public void setFaceAttribute(Attribute attr,
                             double[][] data)

setFaceAttributes

public void setFaceAttributes(DataListSet dls)

setFaceIndices

public void setFaceIndices(DataList data)

setFaceIndices

public void setFaceIndices(int[][] data)

setFaceIndices

public void setFaceIndices(int[] data,
                           int pointCountPerFace)

setFaceIndices

public void setFaceIndices(int[] data)

setUnwrapFaceIndices

public void setUnwrapFaceIndices(DataList data)

setUnwrapFaceIndices

public void setUnwrapFaceIndices(int[][] data)

setUnwrapFaceIndices

public void setUnwrapFaceIndices(int[] data,
                                 int pointCountPerFace)

setUnwrapFaceIndices

public void setUnwrapFaceIndices(int[] data)

setFaceNormals

public void setFaceNormals(DataList data)

setFaceNormals

public void setFaceNormals(double[] data)

setFaceNormals

public void setFaceNormals(double[][] data)

setFaceColors

public void setFaceColors(DataList data)

setFaceColors

public void setFaceColors(double[] data)

setFaceColors

public void setFaceColors(Color[] data)

setFaceColors

public void setFaceColors(double[][] data)

setFaceLabels

public void setFaceLabels(String[] data)

unwrapVertexAttributes

public boolean[] unwrapVertexAttributes(boolean[] data,
                                        int entriesPerVertex)

unwrapVertexAttributes

public static boolean[] unwrapVertexAttributes(boolean[] data,
                                               int entriesPerVertex,
                                               int[][] faceIndices,
                                               int[][] unwrapFaceIndices,
                                               int numberOfUnwrapVertices)

unwrapVertexAttributes

public char[] unwrapVertexAttributes(char[] data,
                                     int entriesPerVertex)

unwrapVertexAttributes

public static char[] unwrapVertexAttributes(char[] data,
                                            int entriesPerVertex,
                                            int[][] faceIndices,
                                            int[][] unwrapFaceIndices,
                                            int numberOfUnwrapVertices)

unwrapVertexAttributes

public double[] unwrapVertexAttributes(double[] data,
                                       int entriesPerVertex)

unwrapVertexAttributes

public static double[] unwrapVertexAttributes(double[] data,
                                              int entriesPerVertex,
                                              int[][] faceIndices,
                                              int[][] unwrapFaceIndices,
                                              int numberOfUnwrapVertices)

unwrapVertexAttributes

public <E> E[] unwrapVertexAttributes(E[] data)

unwrapVertexAttributes

public static <E> E[] unwrapVertexAttributes(E[] data,
                                             int[][] faceIndices,
                                             int[][] unwrapFaceIndices,
                                             int numberOfUnwrapVertices)

unwrapVertexAttributes

public float[] unwrapVertexAttributes(float[] data,
                                      int entriesPerVertex)

unwrapVertexAttributes

public static float[] unwrapVertexAttributes(float[] data,
                                             int entriesPerVertex,
                                             int[][] faceIndices,
                                             int[][] unwrapFaceIndices,
                                             int numberOfUnwrapVertices)

unwrapVertexAttributes

public int[] unwrapVertexAttributes(int[] data,
                                    int entriesPerVertex)

unwrapVertexAttributes

public static int[] unwrapVertexAttributes(int[] data,
                                           int entriesPerVertex,
                                           int[][] faceIndices,
                                           int[][] unwrapFaceIndices,
                                           int numberOfUnwrapVertices)

unwrapVertexAttributes

public long[] unwrapVertexAttributes(long[] data,
                                     int entriesPerVertex)

unwrapVertexAttributes

public static long[] unwrapVertexAttributes(long[] data,
                                            int entriesPerVertex,
                                            int[][] faceIndices,
                                            int[][] unwrapFaceIndices,
                                            int numberOfUnwrapVertices)