public void mouseDragged(MouseEvent e) { int x = e.getX(); int y = e.getY(); float diffX = (float)(x - prevMouseX); float diffY = (float)(y - prevMouseY); if (mouseRDown) { rendu.rotateY(diffX / 100); rendu.rotateX(diffY / 100); } if (mouseLDown) { rendu.translate(Espace.ORIGIN4, new Point4d((x - 620)*0.002, 0.0, 0.0, 1.0)); } prevMouseX = x; prevMouseY = y; }
public static < V extends Vertex<V, E, F> & HasXYZW, E extends Edge<V, E, F>, F extends Face<V, E, F> > double[][] getBBox(HalfEdgeDataStructure<V, E, F> surface) { double result[][] = new double[2][3]; Point4d p0 = surface.getVertex(0).getXYZW(); VecmathTools.dehomogenize(p0); result[0] = new double[]{p0.x, p0.y, p0.z}; result[1] = result[0].clone(); for (int i=1; i< surface.numVertices(); i++) { Point4d p = surface.getVertex(i).getXYZW(); VecmathTools.dehomogenize(p); if ( result[0][0] > p.x ) result[0][0] = p.x; if ( result[1][0] < p.x ) result[1][0]= p.x; if ( result[0][1] > p.y ) result[0][1] = p.y; if ( result[1][1] < p.y ) result[1][1]= p.y; if ( result[0][2] > p.z ) result[0][2] = p.z; if ( result[1][2] < p.z ) result[1][2]= p.z; } return result; }
public static double distFromPointToLine(Point4d x0, Point4d x1, Point4d x2) { Point3d v = p4top3(x0), l = p4top3(x1), r = p4top3(x2); // calculate |v|, that is, the distance from the coordinate // v to the line (l, r) // |(r - l) x (l - v) | // this is given by |v| = ----------------------- // |(r - l)| // where a,b are points of the line and c the point to measure // TODO can get rid of sqrt if we want, but it is no big deal Vector3d rl = new Vector3d(); rl.sub(r, l); Vector3d lv = new Vector3d(); lv.sub(l, v); Vector3d temp = new Vector3d(); temp.cross(rl, lv); double dist = temp.length()/rl.length(); return dist; }
public AnimatedTranslation(double d, Point4d pS, Point4d pE, Rendu r) { super(d); pStart = new Point4d(pS); pEnd = new Point4d(pE); pCurrent = new Point4d(pS); oCurrent = new Point4d(); rendu = r; }
public void translate(Point4d a, Point4d b) { Matrix4d t = EspaceHyperbolique.translate(a, b); for (Objet o : listeObjets) o.applyTransform(t); }
public static void projectInverseStereographic(Point2d p2d, Point4d p4d, double scale) { double x = p2d.x / scale; double y = p2d.y / scale; double nx = 2 * x; double ny = x*x + y*y - 1; double nz = 2 * y; double nw = ny + 2; p4d.set(nx, ny, nz, nw); }
public static Point4d cross(Point4d p1, Point4d p2){ dehomogenize(p1); dehomogenize(p2); Point4d result = new Point4d(); result.x = p1.y * p2.z - p1.z * p2.y; result.y = p1.z * p2.x - p1.x * p2.z; result.z = p1.x * p2.y - p1.y * p2.x; result.w = 1.0; return result; }
final void setIntersectPointDis( Point4d pickLocation ) { // System.err.println( "setIntersectPointDis pickLocation= "+pickLocation); intersectPoint.x = pickLocation.x; intersectPoint.y = pickLocation.y; intersectPoint.z = pickLocation.z; pickDistance = pickLocation.w; }
private void doSelect(PickShape pickShape, UnorderList hitArrList, BHNode bh, Point4d pickPos) { if ((bh == null) || (bh.bHull.isEmpty())) { return; } switch(bh.nodeType) { case BHNode.BH_TYPE_LEAF: if (((BHLeafNode)(bh)).isEnable() && (((BHLeafNode) bh).leafIF instanceof GeometryAtom) && ((GeometryAtom) (((BHLeafNode) bh).leafIF)).source.isPickable && pickShape.intersect(bh.bHull, pickPos)) { hitArrList.add(bh); } break; case BHNode.BH_TYPE_INTERNAL: if (pickShape.intersect(bh.bHull, pickPos)) { doSelect(pickShape, hitArrList, ((BHInternalNode)bh).getRightChild(), pickPos); doSelect(pickShape, hitArrList, ((BHInternalNode)bh).getLeftChild(), pickPos); } break; } }
private BHNode doSelectAny(PickShape pickShape, BHNode bh, Point4d pickPos) { BHNode hitNode = null; if((bh == null) || (bh.bHull.isEmpty())) return null; switch(bh.nodeType) { case BHNode.BH_TYPE_LEAF: if (((BHLeafNode)(bh)).isEnable() && (((BHLeafNode) bh).leafIF instanceof GeometryAtom) && ((GeometryAtom) (((BHLeafNode) bh).leafIF)).source.isPickable && pickShape.intersect(bh.bHull, pickPos)) { return bh; } break; case BHNode.BH_TYPE_INTERNAL: if (pickShape.intersect(bh.bHull, pickPos)) { hitNode = doSelectAny(pickShape, ((BHInternalNode)bh).getRightChild(), pickPos); if (hitNode != null) { return hitNode; } return doSelectAny(pickShape, ((BHInternalNode)bh).getLeftChild(), pickPos); } break; } return null; }
public static double dotProduct(Point4d x, Point4d y) { return (x.x*y.x + x.y*y.y + x.z*y.z) / (x.w * y.w); }
public static double minkowski(Point4d x, Point4d y) { return x.x*y.x + x.y*y.y + x.z*y.z - x.w*y.w; }
public void setCoord4d(Point4d p) { }
public static void dehomogenize(Point4d p){ p.x /= p.w; p.y /= p.w; p.z /= p.w; p.w = 1.0; }
public static void normalize(Point4d p){ p.scale(1 / p.distance(zero4d)); }
public static double length(Point4d p){ dehomogenize(p); return p.distance(zero4d); }
public static double distance(Point4d p1, Point4d p2) { dehomogenize(p1); dehomogenize(p2); return Math.sqrt((p1.x - p2.x)*(p1.x - p2.x) + (p1.y - p2.y)*(p1.y - p2.y) + (p1.z - p2.z)*(p1.z - p2.z)); }
public static void sphereMirror(Point4d p){ VecmathTools.dehomogenize(p); double lengthSqr = (p.x*p.x + p.y*p.y + p.z*p.z); p.w = lengthSqr; VecmathTools.dehomogenize(p); }
public static boolean isNAN(Point4d p){ return isNaN(p.x) || isNaN(p.y) || isNaN(p.z) || isNaN(p.w); }
public static Point3d p4top3(Point4d p) { Point4d t = new Point4d(p); dehomogenize(t); return new Point3d(t.x, t.y, t.z); }
public static Vector3d p4tov3(Point4d p) { Point4d t = new Point4d(p); dehomogenize(t); return new Vector3d(t.x, t.y, t.z); }
public static Point3d toPoint3d(Point4d p) { return new Point3d(p.x, p.y, p.z); }
public static Point3f toPoint3f(Point4d p) { return new Point3f((float) p.x, (float) p.y, (float) p.z); }
public static Point4d toPoint4d(Point3d p, double w) { return new Point4d(p.x, p.y, p.z, w); }
/** * Return true if shape intersect with bounds. * The point of intersection is stored in pickPos. */ abstract boolean intersect(Bounds bounds, Point4d pickPos);
public void setCoord4d(Point4d p) {}
public Point4d getXYZW();
public void setXYZW(Point4d p);