Skip to content

J
Java_fleet_detection
Commit a2498efb authored by Nguyeng Hoang Giang's avatar Nguyeng Hoang Giang
Browse files
Options

add

parent 0033e091
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 1498 additions and 46 deletions
build.gradle
View file @ a2498efb
......@@ -16,22 +16,21 @@ ext{
}
dependencies {
List axisExGroups = [ 'org.bytedeco.javacpp-presets']
List axisExModules = [ 'ffmpeg' , 'artoolkitplus', 'ffmpeg-platform']
implementation('org.bytedeco:opencv:4.5.1-1.5.5:android-x86')
implementation('org.bytedeco:opencv:4.3.0-1.5.3:android-x86_64')
implementation('org.bytedeco:openblas:0.3.13-1.5.5:android-x86')
implementation('org.bytedeco:openblas:0.3.9-1.5.3:android-x86_64')
implementation(group:'org.apache.commons', name: 'commons-collections4', version: '4.0')
implementation(group :'org.bytedeco', name: 'javacv-platform', version: '1.5.5'){
exclude group: 'org.bytedeco.javacpp-presets'
axisExGroups.each { exclude group: "$it" }
axisExModules.each {exclude module: "$it"}
}
implementation('org.apache.commons:commons-lang3:3.12.0')
implementation('com.github.sh0nk:matplotlib4j:0.5.0')
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
// testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
// testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
}
test {
......
src/main/java/Entity/Face.java 0 → 100644
View file @ a2498efb
This diff is collapsed.
src/main/java/Entity/FaceList.java 0 → 100644
View file @ a2498efb
package Entity;
public class FaceList {
private Face head;
private Face tail;
/**
* Clears this list
*/
public void clear() {
head = tail = null;
}
/**
* Adds a vertex to the end of this list
*/
public void add(Face vtx) {
if (head == null) {
head = vtx;
} else {
tail.next = vtx;
}
vtx.next = null;
tail = vtx;
}
public Face first() {
return head;
}
/**
* Returns true if this list is empty
*/
public boolean isEmpty() {
return head == null;
}
}
src/main/java/Entity/HalfEdge.java 0 → 100644
View file @ a2498efb
package Entity;
public class HalfEdge {
/**
* The vertex associated with the heat of this half-edge
*/
protected Vertex vertex;
/**
* Triangular face associated with this half-edge
*/
protected Face face;
/**
* Next haft-edge in the triangle
*/
protected HalfEdge next;
/**
* Previous half-edge in the reiangle
*/
protected HalfEdge prev;
/**
* Half-edge associated with the opposite triangle adjacent to this edge
*/
protected HalfEdge opposite;
public HalfEdge() {
}
/**
* Constructs a HalfEdge with head vertex and left-hand triangular face
*
* @param vertex head vertex
* @param face left-hand triangular face
*/
public HalfEdge(Vertex vertex, Face face) {
this.vertex = vertex;
this.face = face;
}
/**
* Gets the triangular face located to the left of this half-edge
*
* @return left-hand triangular face
*/
public Face getFace() {
return face;
}
/**
* Gets the value of the next edge adjacent (counter-clockwise) to this one within the triangle
*
* @return next adjacent edge
*/
public HalfEdge getNext() {
return next;
}
/**
* Sets the value of the next edge adjacent (counter-clockwise) to this one within the triangle
*
* @param next next adjacent edge
*/
public void setNext(HalfEdge next) {
this.next = next;
}
/**
* Gets the value of the previous edge adjacent (clockwise) to this one within the triangle
*
* @return previous adjacent edge
*/
public HalfEdge getPrev() {
return prev;
}
/**
* Sets the value of the previous edge adjacent (clockwise) to this one within the triangle
*
* @param prev previous adjacent edge
*/
public void setPrev(HalfEdge prev) {
this.prev = prev;
}
/**
* Returns the half-edge opposite to this half-edge
*
* @return opposite half-edge
*/
public HalfEdge getOpposite() {
return opposite;
}
/**
* Sets the half-edge opposite to this half-edge
*
* @param opposite opposite half-edge
*/
public void setOpposite(HalfEdge opposite) {
this.opposite = opposite;
}
/**
* Returns the head vertex associated with this half-edge
*
* @return head vertex
*/
public Vertex head() {
return vertex;
}
/**
* Returns the tail vertex associate with this half-edge
*
* @return
*/
public Vertex tail() {
return prev != null ? prev.vertex : null;
}
/**
* Returns the opposite triangular face associate with this half-edge
*
* @return opposite triangular face
*/
public Face oppositeFace() {
return opposite != null ? opposite.face : null;
}
/**
* Produces a string identifying this half-edge by the point index values of its tail and head vertices
*
* @return identifying string
*/
public String getVertexString() {
if (tail() != null) {
return "" + tail().index + "-" + head().index;
} else {
return "?-" + head().index;
}
}
/**
* Returns the length of this half-edge
*
* @return half-edge length
*/
public double length() {
if (tail() != null) {
return head().pnt.distance(tail().pnt);
} else {
return -1;
}
}
/**
* Returns the length squared of this half-edge
*
* @return half-edge squared length
*/
public double lengthSquared() {
if (tail() != null) {
return head().pnt.distanceSquared(tail().pnt);
} else {
return -1;
}
}
}
src/main/java/Entity/Point3D.java 0 → 100644
View file @ a2498efb
package Entity;
public class Point3D extends Vector3D{
/**
* Create a Point3D amd initializes it to zero
*/
public Point3D() {
}
/**
* Creates a Point3D by copy a vector
* @param v
*/
public Point3D(Vector3D v) {
super(v);
}
/**
* Create a Point3D with the supplied element values
* @param x
* first element
* @param y
* second element
* @param z
* third element
*/
public Point3D(double x, double y, double z) {
super(x, y, z);
}
}
src/main/java/Entity/Vector3D.java 0 → 100644
View file @ a2498efb
package Entity;
public class Vector3D {
static private final double DOUBLE_PREC = 2.2204460492503131e-16;//Precision of a double
public double x;//first element
public double y;//second element
public double z;//third element
//Creates a 3-vector and initializes its elements to 0
public Vector3D() {
}
/**
* Creates a 3-vector by copy existing one
*
* @param v vector to be copied
*/
public Vector3D(Vector3D v) {
set(v);
}
/**
* Creates a 3-vector with the supplied element values
*
* @param x first element
* @param y second element
* @param z third element
*/
public Vector3D(double x, double y, double z) {
set(x, y, z);
}
/**
* Gets a single element of this vector. Element 0, 1, and 2 correspond to x,y and z
*
* @param i element index
* @return element value throws ArrayIndexOutOfBoundsException if i is not in range 0 to 2
*/
public double get(int i) {
switch (i) {
case 0: {
return x;
}
case 1: {
return y;
}
case 2: {
return z;
}
default: {
throw new ArrayIndexOutOfBoundsException(i);
}
}
}
/**
* Sets a single element of this vector. Elements 0, 1, and 2 correspond to
* x, y, and z
*
* @param i element index
* @param value element value
* @return element value throws ArrayIndexOutOfBoundsException if i is not in the range 0 to 2
*/
public void set(int i, double value) {
switch (i) {
case 0: {
x = value;
break;
}
case 1: {
y = value;
break;
}
case 2: {
z = value;
break;
}
default: {
throw new ArrayIndexOutOfBoundsException(i);
}
}
}
/**
* Sets the values of this vector to those of v1
*
* @param v1 vector whose values are copied
*/
public void set(Vector3D v1) {
this.x = v1.x;
this.y = v1.y;
this.z = v1.z;
}
/**
* Sets the values of the vector to the prescribed values
*
* @param x value for first element
* @param y value for second element
* @param z value for third element
*/
public void set(double x, double y, double z) {
this.x = x;
this.y = y;
this.z = z;
}
/**
* Sets the elements of this vector to zero
*/
public void setZero() {
x = 0;
y = 0;
z = 0;
}
/**
* Adds vector v1 to v2 and places the result in this vector
*
* @param v1 left-hand vector
* @param v2 right-hand vector
*/
public void add(Vector3D v1, Vector3D v2) {
x = v1.x + v2.x;
y = v1.y + v2.y;
z = v1.z + v2.z;
}
/**
* Adds this vector to v and places the result in this vector
*
* @param v right-hand vector
*/
public void add(Vector3D v) {
x += v.x;
y += v.y;
z += v.z;
}
/**
* Subs vector v1 from v2 and places the result in this vector
*
* @param v1 left-hand vector
* @param v2 right-hand vector
*/
public void sub(Vector3D v1, Vector3D v2) {
x = v1.x - v2.x;
y = v1.y - v2.y;
z = v1.z - v2.z;
}
/**
* Subs this vector from v and places the result in this vector
*
* @param v right-hand vector
*/
public void sub(Vector3D v) {
x -= v.x;
y -= v.y;
z -= v.z;
}
/**
* Scales the elements of this vector by s
*
* @param s scaling factor
*/
public void scale(double s) {
x = s * x;
y = s * y;
z = s * z;
}
/**
* Scales the elements of vector v by s and place the results in this vector
*
* @param s scaling vector
* @param v vector to be scaled
*/
public void scale(double s, Vector3D v) {
x = s * v.x;
y = s * v.y;
z = s * v.z;
}
/**
* Returns the 2 norm of this vector. This is the square root of the sum of the squares of the elements
*
* @return vector 2 norm
*/
public double norm() {
return Math.sqrt(x * x + y * y + z * z);
}
/**
* Retruns the square of the 2 norm of this vector. this is the sum of the squares of the element
*
* @return square of the 2 norm
*/
public double normSquared() {
return x * x + y * y + z * z;
}
/**
* Returns the Euclidean distance between this vector and vector v
*
* @param v vector destination
* @return distance between this vector and v
*/
public double distance(Vector3D v) {
double dx = x - v.x;
double dy = y - v.y;
double dz = z - v.z;
return Math.sqrt(dx * dx + dy * dy + dz * dz);
}
/**
* Returns the squared of Euclidean distance between this vector and vector v
*
* @param v vector destination
* @return squared distance between this vector and v
*/
public double distanceSquared(Vector3D v) {
double dx = x - v.x;
double dy = y - v.y;
double dz = z - v.z;
return dx * dx + dy * dy + dz * dz;
}
/**
* Returns the dot product of this vector and v1
*
* @param v right-hand vector
* @return dot product
*/
public double dot(Vector3D v) {
return x * v.x + y * v.y + z * v.z;
}
/**
* Normalizes this vector in place
*/
public void normalize() {
double lenSqr = x * x + y * y + z * z;
double err = lenSqr - 1;
if (err > (2 * DOUBLE_PREC) || err < -(2 * DOUBLE_PREC)) {
double len = Math.sqrt(lenSqr);
x /= len;
y /= len;
z /= len;
}
}
/**
* Computes the cross product of v1 and v2 and places the result in this vector
*
* @param v1 left-hand vector
* @param v2 right-hand vector
*/
public void cross(Vector3D v1, Vector3D v2) {
double tmpx = v1.y * v2.z - v1.z * v2.y;
double tmpy = v1.z * v2.x - v1.x * v2.z;
double tmpz = v1.x * v2.y - v1.y - v2.x;
x = tmpx;
y = tmpy;
z = tmpz;
}
@Override
public String toString() {
return "Vector3D{" +
"x=" + x +
", y=" + y +
", z=" + z +
'}';
}
}
src/main/java/Entity/Vertex.java 0 → 100644
View file @ a2498efb
package Entity;
public class Vertex {
/**
* Spatial point associated with this vertex
*/
public Point3D pnt;
/**
* Back index into an array
*/
public int index;
/**
* List forward link
*/
public Vertex prev;
/**
* List backward link
*/
public Vertex next;
/**
* Current face that this vertex is outside of
*/
public Face face;
/**
* Constructs a vertex and sets its coordinates to 0
*/
public Vertex() {
}
/**
* Constructs a vertex with the specified coordinates and index
*/
public Vertex(double x, double y, double z, int idx) {
pnt = new Point3D(x, y, z);
index = idx;
}
}
src/main/java/Entity/VertexList.java 0 → 100644
View file @ a2498efb
package Entity;
public class VertexList {
private Vertex head;
private Vertex tail;
/**
* Clears this list
*/
public void clear() {
head = tail = null;
}
/**
* Adds a vertex to the end of this list
*/
public void add(Vertex vtx) {
if (head == null) {
head = vtx;
} else {
tail.next = vtx;
}
vtx.prev = tail;
vtx.next = null;
tail = vtx;
}
/**
* Adds a chain of vertices to the end of this list
*/
public void addAll(Vertex vtx) {
if (head == null) {
head = vtx;
} else {
tail.next = vtx;
}
vtx.prev = tail;
while (vtx.next != null) {
vtx = vtx.next;
}
tail = vtx;
}
/**
* Deletes a vertex from this list
*/
public void delete(Vertex vtx) {
if (vtx.prev == null) {
head = vtx.next;
} else {
vtx.prev.next = vtx.next;
}
if (vtx.next == null) {
tail = vtx.prev;
} else {
vtx.next.prev = vtx.prev;
}
}
/**
* Deletes a chain of vertices from this list
*/
public void delete(Vertex vtx1, Vertex vtx2) {
if (vtx1.prev == null) {
head = vtx2.next;
} else {
vtx1.prev.next = vtx2.next;
}
if (vtx2.next == null) {
tail = vtx1.prev;
} else {
vtx2.next.prev = vtx1.prev;
}
}
/**
* Inserts a vertex into this list before another specificed vertex
*/
public void insertBefore(Vertex vtx, Vertex next) {
vtx.prev = next.prev;
if (next.prev == null) {
head = vtx;
} else {
next.prev.next = vtx;
}
vtx.next = next;
next.prev = vtx;
}
/**
* return the first element in this list
*/
public Vertex first() {
return head;
}
/**
* Returns true if this list is empty
*/
public boolean isEmpty() {
return head == null;
}
}
src/main/java/Fleet_single_cam.java
View file @ a2498efb
import Entity.Point3D;
import org.opencv.core.Mat;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
public class Fleet_single_cam {
private String id;
......@@ -14,6 +17,7 @@ public class Fleet_single_cam {
private int num_y;
private int num_z;
private boolean show;
private Point3D[] points;
// private
HashMap<String, intArray> side;
......@@ -32,6 +36,14 @@ public class Fleet_single_cam {
return intArray.clone();
}
public int getWidth() {
return intArray[0].length;
}
public int getHeight() {
return intArray.length;
}
public void setIntArray(int[][] intArray) {
this.intArray = intArray;
}
......@@ -126,6 +138,73 @@ public class Fleet_single_cam {
this.side.get("bottom").setIntArray(fill_matrix(bottom));
}
/**
* Create list point3d from 3 side
*/
public void initPoint3d() {
//init point list
List<Point3D> point3dList = new ArrayList<>();
//temp pixel
int xx = 0;
int yy = 0;
int zz = 0;
//get side front, side, bottom
int[][] front = this.side.get("front").getIntArray();
int[][] side = this.side.get("side").getIntArray();
int[][] bottom = this.side.get("bottom").getIntArray();
//add point 0 in side front
zz = num_z + 1;
yy = num_y + 1;
for (int i = 0; i < front.length; i++) {
zz -= 1;
xx = 0;
for (int j = 0; j < front[i].length; j++) {
xx += 1;
//add if point == 0
if (front[i][j] == 0) {
point3dList.add(new Point3D(xx, yy, zz));
}
}
}
//add point 0 in side side
zz = num_z + 1;
xx = 0;
for (int i = 0; i < side.length; i++) {
zz -= 1;
yy = 0;
for (int j = 0; j < side[i].length; j++) {
yy += 1;
//add if point == 0
if (side[i][j] == 0) {
point3dList.add(new Point3D(xx, yy, zz));
}
}
}
//add point 0 in side bottom
zz = 0;
yy = num_y + 1;
for (int i = 0; i < bottom.length; i++) {
yy -= 1;
xx = 0;
for (int j = 0; j < bottom[i].length; j++) {
xx += 1;
//add if point == 0
if (bottom[i][j] == 0) {
point3dList.add(new Point3D(xx, yy, zz));
}
}
}
points = point3dList.toArray(new Point3D[point3dList.size()]);
}
public Point3D[] getPoints() {
return points;
}
private int[][] padding(int[][] matrix, int require_height, int require_width) {
//get width, height
......@@ -160,7 +239,6 @@ public class Fleet_single_cam {
}
return return_matrix;
}
......
src/main/java/main.java
View file @ a2498efb
import org.bytedeco.javacpp.Loader;
import org.bytedeco.opencv.opencv_java;
import java.util.Arrays;
public class main {
public static void main(String[] args) {
Loader.load(opencv_java.class);
//Khoi tạo 1 cam, nhận ảnh tĩnh vào
Fleet_single_cam cam = new Fleet_single_cam("a", "5b8ab6b219c9d6978fd827.jpg", 0.5, 5, 5, 4, false);
Fleet_single_cam cam1 = new Fleet_single_cam("a", "1da36bd1c4aa0bf452bb24.jpg", 0.5, 5, 5, 4, false);
//create front side, add 4 đỉnh của side front vào
cam1.add_side("front", new float[][]{
new float[]{681, 54},
new float[]{1250, 115},
new float[]{984, 528},
new float[]{679, 366}
});
//create mặt side, add 4 đỉnh của mặt side vào
cam1.add_side("side", new float[][]{
new float[]{8, 152},
new float[]{681, 54},
new float[]{679, 366},
new float[]{288, 545}
});
//create bottom side, add 4 đỉnh của side bottom vào
cam1.add_side("bottom", new float[][]{
new float[]{679, 366},
new float[]{984, 528},
new float[]{732, 955},
new float[]{288, 545}
});
cam1.refine_matrix();
cam1.initPoint3d();
//Khoi tạo 1 cam, nhận ảnh tĩnh vào
Fleet_single_cam cam2 = new Fleet_single_cam("a", "5b8ab6b219c9d6978fd827.jpg", 0.5, 5, 5, 4, false);
//create front side, add 4 đỉnh của side front vào
cam.add_side("front", new float[][]{
cam2.add_side("front", new float[][]{
new float[]{687, 8},
new float[]{1264, 54},
new float[]{1027, 432},
......@@ -18,7 +50,7 @@ public class main {
});
//create mặt side, add 4 đỉnh của mặt side vào
cam.add_side("side", new float[][]{
cam2.add_side("side", new float[][]{
new float[]{12, 132},
new float[]{687, 8},
new float[]{672, 305},
......@@ -26,46 +58,40 @@ public class main {
});
//create bottom side, add 4 đỉnh của side bottom vào
cam.add_side("bottom", new float[][]{
cam2.add_side("bottom", new float[][]{
new float[]{672, 305},
new float[]{1027, 432},
new float[]{817, 923},
new float[]{275, 497}
});
cam.refine_matrix();
//print matrix
int[][] matrix = cam.side.get("front").getIntArray();
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[0].length; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
System.out.println();
int[][] matrix2 = cam.side.get("side").getIntArray();
for (int i = 0; i < matrix2.length; i++) {
for (int j = 0; j < matrix2[0].length; j++) {
System.out.print(matrix2[i][j] + " ");
}
System.out.println();
}
System.out.println();
int[][] matrix3 = cam.side.get("bottom").getIntArray();
for (int i = 0; i < matrix2.length; i++) {
cam2.refine_matrix();
cam2.initPoint3d();
// Point3d[] poly = Arrays.copyOf(cam1.getPoints(), cam1.getPoints().length+cam2.getPoints().length);
// System.arraycopy(cam2.getPoints(), 0, poly, cam1.getPoints().length, cam2.getPoints().length);
//
// QuickHull3D hull = new QuickHull3D();
// hull.build(poly);
// System.out.println("Vertices:");
// Point3d[] vertices = hull.getVertices();
// for (int i = 0; i < vertices.length; i++) {
// Point3d pnt = vertices[i];
// System.out.println(pnt.x + " " + pnt.y + " " + pnt.z);
// }
//
// System.out.println("Faces:");
// int[][] faceIndices = hull.getFaces();
// for (int i = 0; i < vertices.length; i++) {
// for (int k = 0; k < faceIndices[i].length; k++) {
// System.out.print(faceIndices[i][k] + " ");
// }
// System.out.println("");
// }
for (int j = 0; j < matrix3[0].length; j++) {
System.out.print(matrix3[i][j] + " ");
}
System.out.println();
}
}
}
src/main/java/utils/QuickHull3d.java 0 → 100644
View file @ a2498efb
package utils;
import Entity.*;
import java.util.Vector;
public class QuickHull3d {
/**
* Specifies that the distance tolerance should be computed automatically from the input point data
*/
public static final double AUTOMATIC_TOLERANCE = -1;
protected int findIndex = -1;
//estimated size of the point set
protected double charLength;
protected Vertex[] pointBuffer = new Vertex[0];
protected int[] vertexPointIndices = new int[0];
private Face[] discardedFaces = new Face[3];
private Vertex[] maxVtxs = new Vertex[3];
private Vertex[] minVtxs = new Vertex[3];
protected Vector face = new Vector(16);
protected Vector horizon = new Vector(16);
private FaceList newFaces = new FaceList();
private VertexList unclaimed = new VertexList();
private VertexList claimed = new VertexList();
protected int numVertices;
protected int numFaces;
protected int numPoints;
protected double explicitTolerance = AUTOMATIC_TOLERANCE;
protected double tolerance;
private static final double DOUBLE_PREC = 2.2204460492503131e-16;
/**
* Create a convex hull object and initializes it to the convex hull of a set of points
* @param points
* input points
* @throws IllegalArgumentException
* the number of input points is less than four, or the point appear to be coincident, colinear, or coplanar
*/
public QuickHull3d(Point3D[] points) throws IllegalArgumentException{
build(points, points.length);
}
/**
* Constructs the convex hull of a set of points
* @param points
* input points
* @param nump
* number of input poins
* @throws IllegalArgumentException
* the number of input points is less than four or greater than the length if points, or the points appear to be coincident, colinear, or coplanar
*/
public void build(Point3D[] points, int nump) throws IllegalArgumentException{
if (nump < 4){
throw new IllegalArgumentException("Less than four input points specified");
}
if (points.length < nump){
throw new IllegalArgumentException("Point array too small for specified number of points");
}
initBuffers(nump);
setPoints(points, nump);
buildHull();
}
protected void initBuffers(int nump){
if (pointBuffer.length < nump){
Vertex[] newBuffer = new Vertex[nump];
vertexPointIndices = new int[nump];
for (int i = 0; i < pointBuffer.length; i++){
newBuffer[i] = pointBuffer[i];
}
for (int i = pointBuffer.length; i < nump; i++){
newBuffer[i] = new Vertex();
}
pointBuffer = newBuffer;
}
face.clear();
claimed.clear();
numFaces = 0;
numPoints = nump;
}
protected void setPoints(Point3D[] pnts, int nump) {
for (int i = 0; i < nump; i++){
Vertex vtx = pointBuffer[i];
vtx.pnt.set(pnts[i]);
vtx.index = i;
}
}
protected void buildHull(){
int cnt = 0;
Vertex eyeVtx;
computeMaxAndMin();
createInitialSimplex();
while ((eyeVtx = nextPointToAdd()) != null){
addPointToHull(eyeVtx);
cnt++;
}
reindexFacesAndVertices();
}
protected void computeMaxAndMin(){
//initialize max, min
Vector3D max = new Vector3D();
Vector3D min = new Vector3D();
for (int i=0;i<3;i++){
maxVtxs[i] = minVtxs[i] = pointBuffer[0];
}
max.set(pointBuffer[0].pnt);
min.set(pointBuffer[0].pnt);
//check all point to find max, min
for (int i=1;i<numPoints;i++){
Point3D pnt = pointBuffer[i].pnt;
//find maxVtxs[0] and minVtxs[0] , vectors with max x and min x
if (pnt.x >max.x){
max.x = pnt.x;
maxVtxs[0] = pointBuffer[i];
}else if (pnt.x < min.x){
min.x = pnt.x;
minVtxs[0] = pointBuffer[i];
}
//find maxVtxs[1] and minVtxs[1] , vectors with max y and min y
if (pnt.y >max.y){
max.y = pnt.y;
maxVtxs[1] = pointBuffer[i];
}else if (pnt.y < min.y){
min.y = pnt.y;
minVtxs[1] = pointBuffer[i];
}
//find maxVtxs[2] and minVtxs[2] , vectors with max z and min z
if (pnt.z >max.z){
max.z = pnt.z;
maxVtxs[2] = pointBuffer[i];
}else if (pnt.z < min.z){
min.z = pnt.z;
minVtxs[2] = pointBuffer[i];
}
charLength = Math.max(max.x - min.x, max.y - min.y);
charLength = Math.max(max.z - min.z, charLength);
if (explicitTolerance == AUTOMATIC_TOLERANCE){
tolerance = 3* DOUBLE_PREC * (Math.max(Math.abs(max.x), Math.abs(min.x)) + Math.max(Math.abs(max.y), Math.abs(min.y)) + Math.max(Math.abs(max.z), Math.abs(min.z)));
}else{
tolerance = explicitTolerance;
}
}
}
protected void createInitialSimplex() throws IllegalArgumentException{
double max = 0;
int imax = 0;
for (int i = 0; i< 3; i++){
double diff = maxVtxs[i].pnt.get(i)-minVtxs[i].pnt.get(i);
if (diff > max){
max = diff;
imax = i;
}
}
if (max <= tolerance){
throw new IllegalArgumentException("Input points appear to be conicident");
}
Vertex[] vtx = new Vertex[4];
//set first two vertices to be those with the greatest one dimensional separation
vtx[0] = maxVtxs[imax];
vtx[1] = minVtxs[imax];
// set third vertex to be the vertex farthest from the line between vtx0 and vtx1
Vector3D u01 = new Vector3D();
Vector3D diff02 = new Vector3D();
Vector3D nrml = new Vector3D();
}
}
test_result.txt 0 → 100644
View file @ a2498efb
Vertices:
5.0 6.0 3.0
1.0 6.0 1.0
5.0 6.0 1.0
0.0 4.0 2.0
0.0 1.0 1.0
0.0 5.0 1.0
1.0 5.0 0.0
0.0 2.0 2.0
5.0 5.0 0.0
1.0 1.0 0.0
5.0 1.0 0.0
Faces:
1 3 0
9 6 8 10
5 3 1
5 1 6
2 8 6 1
2 1 0
2 0 10 8
7 10 0
7 0 3
4 9 10
4 10 7
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment