import javax.media.opengl.*;
import javax.media.opengl.glu.*;
+// FEATURE: octree for nearest-point queries? Could make moving points around problematic.
+
public class Geom implements Iterable<Geom.T> {
public static float EPSILON = (float)0.000001;
public Iterator<T> iterator() { return ts.iterator(); }
+ public P newP(double x, double y, double z) { return newP((float)x, (float)y, (float)z); }
public P newP(float x, float y, float z) {
P p = new P(x, y, z);
P p2 = ps.get(p);
return e;
}
+ public T newT(P p1, P p2, P p3) {
+ return newT(newE(p1, p2), newE(p2, p3), newE(p3, p1), p3.minus(p1).cross(p2.minus(p1)));
+ }
+
/** ensures that e1.cross(e2).norm()==e2.cross(e3).norm()==e3.cross(e1).norm()==t.norm() */
public T newT(E e1, E e2, E e3, V norm) {
P p12 = e1.shared(e2);
/** [UNIQUE] point in 3-space */
public final class P {
- public final float x, y, z;
+
+ float x, y, z;
+
private T t = null; // any of the triangles incident at this point
+
+ private M binding = new M();
+ private P bound_to = this;
+
+ public void unbind() { bound_to = null; binding = null; }
+ public void bind(P p) { bind(p, new M()); }
+ public void bind(P p, M binding) {
+
+ P px = p;
+ do {
+ if (px==this) return; // already bound
+ px = px.bound_to;
+ } while(px != p);
+
+ P temp_bound_to = p.bound_to;
+ M temp_binding = p.binding;
+ p.bound_to = this.bound_to;
+ p.binding = binding.times(this.binding); // FIXME: may have order wrong here
+ this.bound_to = temp_bound_to;
+ this.binding = temp_binding.times(temp_binding); // FIXME: may have order wrong here
+ }
+
+ public void move(V v) {
+ P p = this;
+ do {
+ p.x = p.x+v.x;
+ p.y = p.y+v.y;
+ p.z = p.z+v.z;
+ v = v.times(binding);
+ p = p.bound_to;
+ } while (p != this);
+ }
+
public P(float x, float y, float z) { this.x = x; this.y = y; this.z = z; }
public V minus(P p) { return new V(x-p.x, y-p.y, z-p.z); }
public P plus(V v) { return newP(x+v.x, y+v.y, z+v.z); }
+ public P times(M m) { return m.apply(this); }
public boolean equals(Object o) {
if (o==null || !(o instanceof P)) return false;
P p = (P)o;
/** vector in 3-space */
public final class V {
- private final float x, y, z;
+ public final float x, y, z;
+ public V(double x, double y, double z) { this((float)x, (float)y, (float)z); }
public V(float x, float y, float z) { this.x = x; this.y = y; this.z = z; }
public V cross(V v) { return new V(y*v.z-z*v.y, z*v.x-x*v.z, x*v.y-y*v.x); }
public V plus(V v) { return new V(x+v.x, y+v.y, z+v.z); }
- public V norm() { float m = mag(); return new V(x/m, y/m, z/m); }
+ public V norm() { return div(mag()); }
+ public V times(M m) { return m.apply(this); }
public float mag() { return (float)Math.sqrt(x*x+y*y+z*z); }
public float dot(V v) { return x*v.x + y*v.y + z*v.z; }
public V times(float mag) { return new V(x*mag, y*mag, z*mag); }
+ public V div(float mag) { return new V(x/mag, y/mag, z/mag); }
public String toString() { return "<"+x+","+y+","+z+">"; }
}
if (e2.t1 == null) e2.t1 = this; else if (e2.t2 == null) e2.t2 = this; else throw new Error("non-manifold surface");
if (e3.t1 == null) e3.t1 = this; else if (e3.t2 == null) e3.t2 = this; else throw new Error("non-manifold surface");
// FIXME: check that triangles we share an edge with agree on the direction of the normal vector
- // FIXME: check for sealed/watertight surface once construction is complete (an infer normal(s)?)
+ // FIXME: check for sealed/watertight surface once construction is complete (and infer normal(s)?)
}
public V norm() {
P p1 = e1.shared(e2);
/** returns the angle at point p */
public double angle(P p) {
- V v1 = firstEdge(p).other(p).minus(p);
- V v2 = secondEdge(p).other(p).minus(p);
+ V v1 = nextE(p).other(p).minus(p);
+ V v2 = prevE(p).other(p).minus(p);
return Math.acos(v1.norm().dot(v2.norm()));
}
}
+
/** matrix */
public class M {
+ public M() { }
+ public P apply(P p) { return p; }
+ public V apply(V v) { return v; }
+ public M invert() { return this; }
+ public M times(M m) { return this; }
}
}
/** magnification factor */
private static final float MAG = 1;
+ Geom.V[] translations;
+ Geom.P[] points;
+
public Main(StlFile stlf) {
+
+ Geom.P ltf = geom.newP(-0.2, 0.1, 0.1);
+ Geom.P mtf = geom.newP( 0.0, 0.1, 0.1);
+ Geom.P rtf = geom.newP( 0.2, 0.1, 0.1);
+ Geom.P ltn = geom.newP(-0.2, 0.1, -0.1);
+ Geom.P mtn = geom.newP( 0.0, 0.1, -0.1);
+ Geom.P rtn = geom.newP( 0.2, 0.1, -0.1);
+ Geom.P lbf = geom.newP(-0.2, -0.1, 0.1);
+ Geom.P mbf = geom.newP( 0.0, -0.1, 0.1);
+ Geom.P rbf = geom.newP( 0.2, -0.1, 0.1);
+ Geom.P lbn = geom.newP(-0.2, -0.1, -0.1);
+ Geom.P mbn = geom.newP( 0.0, -0.1, -0.1);
+ Geom.P rbn = geom.newP( 0.2, -0.1, -0.1);
+
+ points = new Geom.P[] {
+ ltf,
+ mtf,
+ rtf,
+ ltn,
+ mtn,
+ rtn,
+ lbf,
+ mbf,
+ rbf,
+ lbn,
+ mbn,
+ rbn
+ };
+
+ translations = new Geom.V[] {
+ geom.new V(-0.2, 0.2, 0),
+ geom.new V( 0.2, 0.2, 0),
+ geom.new V(-0.2, -0.2, 0),
+ geom.new V( 0.2, -0.2, 0),
+ geom.new V( 0.4, 0, 0),
+ geom.new V(-0.4, 0, 0),
+ geom.new V( 0, 0, 0.2),
+ geom.new V( 0, 0, -0.2),
+ };
+
+ for(Geom.V v : translations) {
+ for(Geom.P p1 : points) {
+ for(Geom.P p2 : points) {
+ if (p1.plus(v).minus(p2).mag() < Geom.EPSILON) {
+ System.out.println("bind " + p1 + " to " + p2);
+ p1.bind(p2);
+ }
+ }
+ }
+ }
+
+ // top
+ geom.newT(ltf, mtf, mtn);
+ geom.newT(mtn, ltn, ltf);
+ geom.newT(mtf, rtf, rtn);
+ geom.newT(rtn, mtn, mtf);
+
+ // bottom (swap normals)
+ geom.newT(mbf, lbf, mbn);
+ geom.newT(lbn, mbn, lbf);
+ geom.newT(rbf, mbf, rbn);
+ geom.newT(mbn, rbn, mbf);
+
+ // left
+ geom.newT(ltf, ltn, lbn);
+ geom.newT(lbn, lbf, ltf);
+
+ // right (swap normals)
+ geom.newT(rtn, rtf, rbn);
+ geom.newT(rbf, rbn, rtf);
+
+ // front
+ geom.newT(ltn, mtn, mbn);
+ geom.newT(ltn, mbn, lbn);
+ geom.newT(mtn, rtn, rbn);
+ geom.newT(mtn, rbn, mbn);
+
+ // back
+ geom.newT(mtf, ltf, mbf);
+ geom.newT(mbf, ltf, lbf);
+ geom.newT(rtf, mtf, rbf);
+ geom.newT(rbf, mtf, mbf);
+
+
+ /*
for(int i=0; i<stlf.coordArray.length; i+=3) {
Geom.P p0 = geom.newP(stlf.coordArray[i+0].x * MAG, stlf.coordArray[i+0].y * MAG, stlf.coordArray[i+0].z * MAG);
Geom.P p1 = geom.newP(stlf.coordArray[i+1].x * MAG, stlf.coordArray[i+1].y * MAG, stlf.coordArray[i+1].z * MAG);
Geom.V n = geom.new V(stlf.normArray[i/3].x * MAG, stlf.normArray[i/3].y * MAG, stlf.normArray[i/3].z * MAG);
Geom.T t = geom.newT(geom.newE(p0, p1), geom.newE(p1, p2), geom.newE(p2, p0), n);
}
+ */
+
+
+ mtf.move(geom.new V(0, (float)-0.05, (float)0.05));
+
}
/**
GL gl = gld.getGL();
GLU glu = new GLU();
gl.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+ gl.glClearDepth(1.0);
gl.glViewport(0, 0, 500, 300);
gl.glMatrixMode(GL.GL_PROJECTION);
+ gl.glEnable(GL.GL_DEPTH_TEST);
+ gl.glDepthFunc(GL.GL_LEQUAL);
+
gl.glLoadIdentity();
+ gl.glRotatef((float)45, 1, 1, 1);
+
//glu.gluOrtho2D(0.0, 500.0, 0.0, 300.0);
display(gld);
}
+ public static int angle = 0;
+
public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) { }
public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean deviceChanged) { }
public void display(GLAutoDrawable drawable) {
- float red = 0.0f;
- float green = 0.0f;
- float blue = 0.0f;
GL gl = drawable.getGL();
- gl.glClear(GL.GL_COLOR_BUFFER_BIT);
+ gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
gl.glPointSize(5.0f);
+ gl.glLoadIdentity();
+ gl.glRotatef(angle, 1, 1, 1);
+ gl.glBegin(GL.GL_TRIANGLES);
+ draw(gl, true);
+ gl.glEnd();
+
+ for(Geom.V v1 : translations) {
+ if (v1.z==0 && v1.y==0) continue;
+ Geom.V v = v1.times((float)1.1);
+ gl.glTranslatef(v.x, v.y, v.z);
+ draw(gl, false);
+ gl.glTranslatef(-v.x, -v.y, -v.z);
+ }
+ }
+
+ private void draw(GL gl, boolean triangles) {
+ float red = 0.0f;
+ float green = 0.0f;
+ float blue = 0.0f;
for(Geom.T t : geom) {
- red -= .09f;
- green -= .12f;
- blue -= .15f;
if (red < 0.15) red = 1.0f;
if (green < 0.15) green = 1.0f;
if (blue < 0.15) blue = 1.0f;
+ red -= .09f;
+ green -= .12f;
+ blue -= .15f;
gl.glColor3f(red, green, blue);
- gl.glBegin(GL.GL_TRIANGLES);
- t.glVertices(gl);
- gl.glEnd();
-
+ //gl.glBegin(GL.GL_LINES);
+ if (triangles) {
+ gl.glBegin(GL.GL_TRIANGLES);
+ t.glVertices(gl);
+ gl.glEnd();
+ } else {
+ gl.glBegin(GL.GL_LINES);
+ t.e1.p1.glVertex(gl);
+ t.e1.p2.glVertex(gl);
+ t.e2.p1.glVertex(gl);
+ t.e2.p2.glVertex(gl);
+ t.e3.p1.glVertex(gl);
+ t.e3.p2.glVertex(gl);
+ gl.glEnd();
+ }
+ /*
Geom.P centroid = t.centroid();
gl.glBegin(GL.GL_LINES);
- /*
+ gl.glColor3f(1, 1, 1);
centroid.glVertex(gl);
centroid.plus(t.norm().times(t.diameter())).glVertex(gl);
- */
t.p1().glVertex(gl);
t.p1().plus(t.p1().norm().times(t.diameter())).glVertex(gl);
gl.glEnd();
-
-
+ */
}
}
f.add(glcanvas, BorderLayout.CENTER);
f.show();
f.setSize(500, 300);
+ while(true) {
+ Thread.sleep(100);
+ angle+=5;
+ glcanvas.repaint();
+ }
}
}
\ No newline at end of file
projects / anneal.git / commitdiff