private void populate() { // set up for a new population Vector oldPop = this.positions; this.positions = new Vector(50, 50); // first browse the old population and make changes for (int i = 0; i < oldPop.size(); i++) { Position a = (Position) oldPop.get(i); if (a.symPosNo < this.symPos.length) { Point3d sPos = this.symPos[a.symPosNo]; if (sPos != null) { Point3d newPos = new Point3d(sPos); newPos.add(a.expandTranslation); if (this.isPosInBounds(newPos) && Model3d.this.getAtomHere(this.positions, newPos) == null) { a.changePos(newPos); this.positions.add(a); // System.out.println("move "+a); continue; } } } // invalid, duplicate or out of bounds, remove // System.out.println("del "+a); a.del(); } // now add potentially new appeared atoms for (double i = -Math.ceil(Model3d.this.exm - 1); i <= Math.floor(Model3d.this.exp + 1) + 1; i++) for (double j = -Math.ceil(Model3d.this.eym - 1); j <= Math.floor(Model3d.this.eyp + 1) + 1; j++) for (double k = -Math.ceil(Model3d.this.ezm - 1); k <= Math.floor(Model3d.this.ezp + 1) + 1; k++) { Vector3d v = new Vector3d(i, j, k); for (int l = 0; l < this.symPos.length; l++) { if (this.symPos[l] == null) continue; Point3d p = new Point3d(this.symPos[l]); p.add(v); // TODO if (this.isPosInBounds(p) && Model3d.this.getAtomHere(this.positions, p) == null) { // if (isPosInBounds(round(p)) && // getAtomHere(positions, p)==null) { Position a = new Position(this.root, this, p, v, this.radius, this.color, l, !this.hidden); this.positions.add(a); // if (!isPosInBounds(p))System.out.println("xx // "+p); } } } }
public Point3d calcCenterOfRotation() { List<Integer> line = getLongestLayerLine(); // can't determine center of rotation if there are only 2 points // TODO does this ever happen?? if (line.size() < 3) { return subunits.getCentroid(); } Point3d centerOfRotation = new Point3d(); List<Point3d> centers = subunits.getOriginalCenters(); // calculate helix mid points for each set of 3 adjacent subunits for (int i = 0; i < line.size() - 2; i++) { Point3d p1 = new Point3d(centers.get(line.get(i))); Point3d p2 = new Point3d(centers.get(line.get(i + 1))); Point3d p3 = new Point3d(centers.get(line.get(i + 2))); transformationMatrix.transform(p1); transformationMatrix.transform(p2); transformationMatrix.transform(p3); centerOfRotation.add(getMidPoint(p1, p2, p3)); } // average over all midpoints to find best center of rotation centerOfRotation.scale(1 / (line.size() - 2)); // since helix is aligned along the y-axis, with an origin at y = 0, place the center of // rotation there centerOfRotation.y = 0; // transform center of rotation to the original coordinate frame reverseTransformationMatrix.transform(centerOfRotation); // System.out.println("center of rotation: " + centerOfRotation); return centerOfRotation; }
public Transform3D getTransform() { Transform3D transform = new Transform3D(); Point3d target = new Point3d(); target.add(direction, position); Point3d zoomedPosition = new Point3d(); zoomedPosition.scaleAdd(-zoom / direction.length(), direction, target); transform.lookAt(zoomedPosition, target, up); transform.invert(); return transform; }
/** * Rescales Point2 so that length 1-2 is sum of covalent radii. if covalent radii cannot be found, * use bond length of 1.0 * * @param atom1 stationary atom * @param atom2 moveable atom * @param point2 coordinates for atom 2 * @return new coords for atom 2 */ public static Point3d rescaleBondLength(IAtom atom1, IAtom atom2, Point3d point2) { Point3d point1 = atom1.getPoint3d(); double d1 = atom1.getCovalentRadius(); double d2 = atom2.getCovalentRadius(); // in case we have no covalent radii, set to 1.0 double distance = (d1 < 0.1 || d2 < 0.1) ? 1.0 : atom1.getCovalentRadius() + atom2.getCovalentRadius(); Vector3d vect = new Vector3d(point2); vect.sub(point1); vect.normalize(); vect.scale(distance); Point3d newPoint = new Point3d(point1); newPoint.add(vect); return newPoint; }
public void move() { Vector3d velocity = new Vector3d(cameraXP - cameraXN, 0, cameraZP - cameraZN); velocity.normalize(); if (Double.isNaN(velocity.x)) { velocity = new Vector3d(); } position.add(velocity); if (position.x < -maxX) { position.x = -maxX; } else if (position.x > maxX) { position.x = maxX; } if (position.z < -maxZ) { position.z = -maxZ; } else if (position.z > maxZ) { position.z = maxZ; } }
public synchronized void processCamera() { long dt = (System.nanoTime() - lastUpdateTime) / 1000000; float maxFractionForDT = TRAIL_MAX_FRACTION_DELTA_PER_SEC * (dt / 1000f); // set hit fraction float newHitFraction = trailorCamCollider.getCollisionFraction(currentAvartarHeadPoint, currentCameraMaxVector); // if it's bad just use previous hit fraction if (!Float.isNaN(newHitFraction)) { currentHitFraction = newHitFraction; } // come in a tiny bit so we see through wall to the side less if (currentHitFraction <= 1.0f) { float cameraVectorLen = currentHitFraction * TRAIL_MAX_DIST; cameraVectorLen -= TRAIL_DIST_MARGIN; currentHitFraction = cameraVectorLen / TRAIL_MAX_DIST; } float hitFractionDelta = currentHitFraction - lastSetHitFraction; // clamp the max out ward delta by time (inwards is instant) hitFractionDelta = hitFractionDelta > maxFractionForDT ? maxFractionForDT : hitFractionDelta; currentHitFraction = hitFractionDelta + lastSetHitFraction; // scale the camera vector tempCameraVector.set(currentCameraMaxVector); tempCameraVector.scale(currentHitFraction); // make a camerapoint tempCameraPoint.add(currentAvartarHeadPoint, tempCameraVector); // look at head from camera tempCamTrans.lookAt(tempCameraPoint, currentAvartarHeadPoint, Y_UP); tempCamTrans.invert(); // cos lookAt is not for view platforms? // set the actual view platform getViewPlatformTransform().setTransform(tempCamTrans); // remember state lastSetHitFraction = currentHitFraction; lastUpdateTime = System.nanoTime(); }
/* (non-Javadoc) * @see org.biojava.nbio.structure.quaternary.core.AxisAligner#getGeometricCenter() */ @Override public Point3d getGeometricCenter() { run(); Point3d geometricCenter = new Point3d(); Vector3d translation = new Vector3d(); // reverseTransformationMatrix.get(translation); // TODO does this apply to the helic case? // calculate adjustment around z-axis and transform adjustment to // original coordinate frame with the reverse transformation // Vector3d corr = new Vector3d(0,minBoundary.y+getDimension().y, 0); // reverseTransformationMatrix.transform(corr); // geometricCenter.set(corr); reverseTransformationMatrix.transform(translation); geometricCenter.add(translation); return geometricCenter; }
/** * Calculate new point X in a B-A(-D)-C system. It forms a B-A(-D)(-C)-X system. * * <p>(3) 3 ligands(B, C, D) of refAtom A (i) 1 points required; if A, B, C, D coplanar, no * points. else vector is resultant of BA, CA, DA * * @param aPoint to which substituents are added * @param bPoint first ligand of A * @param cPoint second ligand of A * @param dPoint third ligand of A * @param length A-X length * @return Point3d nwanted points (or null if failed (coplanar)) */ public static Point3d calculate3DCoordinates3( Point3d aPoint, Point3d bPoint, Point3d cPoint, Point3d dPoint, double length) { Vector3d v1 = new Vector3d(aPoint); v1.sub(bPoint); Vector3d v2 = new Vector3d(aPoint); v2.sub(cPoint); Vector3d v3 = new Vector3d(aPoint); v3.sub(dPoint); Vector3d v = new Vector3d(bPoint); v.add(cPoint); v.add(dPoint); if (v.length() < 0.00001) { return null; } v.normalize(); v.scale(length); Point3d point = new Point3d(aPoint); point.add(v); return point; }
/** * Create a core Java 3D View instance and a utility Viewer instance using the attributes gathered * by this object. */ protected Viewer createViewer(boolean setVisible) { Point3d leftEyeCoe, rightEyeCoe; j3dView = new View(); j3dView.setViewPolicy(viewPolicy); if (configBody == null) physicalBody = new PhysicalBody(); else physicalBody = configBody.j3dPhysicalBody; if (configEnv == null) physicalEnvironment = new PhysicalEnvironment(); else physicalEnvironment = configEnv.j3dPhysicalEnvironment; j3dView.setPhysicalBody(physicalBody); j3dView.setPhysicalEnvironment(physicalEnvironment); boolean standardDefaults = true; if (coeCenteringEnableSet && !coeCenteringEnable) { standardDefaults = false; } if (configEnv != null && configEnv.coexistenceToTrackerBase != null) { standardDefaults = false; } else { Iterator i = screens.iterator(); while (i.hasNext()) { ConfigScreen s = (ConfigScreen) i.next(); if (s.trackerBaseToImagePlate != null) { standardDefaults = false; break; } } } if (standardDefaults) { // Coexistence centering has not been explicitly set false, and // the tracker base to image plate and coexistence to tracker base // transforms are unset, so use the standard Java 3D defaults. if (windowEyepointPolicy == -1) windowEyepointPolicy = View.RELATIVE_TO_FIELD_OF_VIEW; if (windowMovementPolicy == -1) windowMovementPolicy = View.PHYSICAL_WORLD; if (windowResizePolicy == -1) windowResizePolicy = View.PHYSICAL_WORLD; if (!coeCenteringEnableSet) coeCenteringEnable = true; } else { // Use multi-screen or calibrated coexistence defaults. if (windowEyepointPolicy == -1) windowEyepointPolicy = View.RELATIVE_TO_COEXISTENCE; if (windowMovementPolicy == -1) windowMovementPolicy = View.VIRTUAL_WORLD; if (windowResizePolicy == -1) windowResizePolicy = View.VIRTUAL_WORLD; if (!coeCenteringEnableSet) coeCenteringEnable = false; } j3dView.setWindowEyepointPolicy(windowEyepointPolicy); j3dView.setWindowMovementPolicy(windowMovementPolicy); j3dView.setWindowResizePolicy(windowResizePolicy); j3dView.setCoexistenceCenteringEnable(coeCenteringEnable); if (centerEyeInCoexistence == null) { centerEyeInCoexistence = new Point3d(0.0, 0.0, 0.4572); } leftEyeCoe = new Point3d(centerEyeInCoexistence); rightEyeCoe = new Point3d(centerEyeInCoexistence); if (stereoEnable) { Point3d leftEyeBody = new Point3d(); Point3d rightEyeBody = new Point3d(); physicalBody.getLeftEyePosition(leftEyeBody); physicalBody.getRightEyePosition(rightEyeBody); leftEyeCoe.add(leftEyeBody); rightEyeCoe.add(rightEyeBody); } j3dView.setLeftManualEyeInCoexistence(leftEyeCoe); j3dView.setRightManualEyeInCoexistence(rightEyeCoe); j3dView.setBackClipPolicy(backClipPolicy); j3dView.setFrontClipPolicy(frontClipPolicy); j3dView.setBackClipDistance(backClipDistance); j3dView.setFrontClipDistance(frontClipDistance); j3dView.setScreenScalePolicy(screenScalePolicy); j3dView.setScreenScale(screenScale); j3dView.setFieldOfView(fieldOfView); j3dView.setTrackingEnable(trackingEnable); j3dView.setSceneAntialiasingEnable(antialiasingEnable); if (screens.size() == 0) { throw new IllegalStateException( errorMessage( creatingCommand, "View \"" + instanceName + "\" has no canvases or screens")); } ConfigScreen[] cs = new ConfigScreen[screens.size()]; screens.toArray(cs); j3dViewer = new Viewer(cs, this, setVisible); return j3dViewer; }
/** * Draws the five sides of the hemicube into the provided drawable * * @param drawable * @param which * @param near * @param far * @param bCollect */ public void drawHemiCube( GLAutoDrawable drawable, int which, double near, double far, boolean bCollect) { // TODO - PART 1 - DRAW HEMICUBE! GL gl = drawable.getGL(); GLU glu = new GLU(); /* Return the face based on which parameter */ int[] vertices = scene.getObject().getFace(which); /* Find the center of the face */ /* Center of the face is the average of the three vertices */ /* Using returned list of vertex indices, find the vertices * corresponding to a particular face */ Vertex v1 = scene.getObject().vertexList.get(vertices[0]); Vertex v2 = scene.getObject().vertexList.get(vertices[1]); Vertex v3 = scene.getObject().vertexList.get(vertices[2]); /* Locate center of face */ /* Average of three vertices */ Point3d centerPoint = new Point3d(); centerPoint = new Point3d(v1.p); centerPoint.add(v2.p); centerPoint.add(v3.p); centerPoint.scale(0.33333); /* Set up camera frame */ /* --- Surface normal --- */ /* Declare points of vertex for face */ Point3d p1 = new Point3d(v1.p); Point3d p2 = new Point3d(v2.p); Point3d p3 = new Point3d(v3.p); /* Declare vector u as p2-p1 */ Point3d uVec = new Point3d(p2); uVec.sub(p1); Vector3d u = new Vector3d(uVec); /* Declare vector v as p3-p1 */ Point3d vVec = new Point3d(p3); vVec.sub(p1); Vector3d v = new Vector3d(vVec); /* Make normal vector */ Vector3d norm = new Vector3d(); norm.cross(u, v); /* --- Vectors Orthonormal to Normal --- */ Point3d vec1pt = new Point3d(p1); vec1pt.sub(p2); Vector3d vec1 = new Vector3d(vec1pt); vec1.cross(vec1, norm); // Cross surface normal with vec1 to get orthogonal vector Vector3d vec2 = new Vector3d(); vec2.cross( norm, vec1); // Cross product of surface normal with new vector vec1 to get 2nd orthogonal vector /* Make unit vectors */ norm.normalize(); vec1.normalize(); vec2.normalize(); /* Set up the five different frustums, and stitch together using viewPort */ /* Viewport to set up the view of the scene */ /* ----- FRONT FACE ----- */ gl.glPushMatrix(); gl.glViewport(0, 0, drawable.getWidth(), drawable.getHeight() / 3); /* Set up frustums for this face */ gl.glMatrixMode(gl.GL_PROJECTION); gl.glLoadIdentity(); gl.glFrustum(-near, near, -near, near, near, far); /* Position camera at center of specified patch (which) */ gl.glMatrixMode(gl.GL_MODELVIEW); gl.glLoadIdentity(); glu.gluLookAt( centerPoint.x, centerPoint.y, centerPoint.z, centerPoint.x + norm.x, centerPoint.y + norm.y, centerPoint.z + norm.z, centerPoint.x + vec1.x, centerPoint.y + vec1.y, centerPoint.z + vec1.z); /* Draw the frustum to screen */ draw(drawable, scene.drawStyle.IDENT); gl.glPopMatrix(); /* ----- BOTTOM FACE ----- */ gl.glPushMatrix(); gl.glViewport(0, drawable.getHeight() / 3, drawable.getWidth(), drawable.getHeight() / 6); gl.glMatrixMode(gl.GL_PROJECTION); gl.glLoadIdentity(); gl.glFrustum(-near, near, 0, near, near, far); /* Position camera at center of specified patch (which) */ gl.glMatrixMode(gl.GL_MODELVIEW); gl.glLoadIdentity(); glu.gluLookAt( centerPoint.x, centerPoint.y, centerPoint.z, centerPoint.x + (-vec1.x), centerPoint.y + (-vec1.y), centerPoint.z + (-vec1.z), centerPoint.x + norm.x, centerPoint.y + norm.y, centerPoint.z + norm.z); /* Draw the frustum to screen */ draw(drawable, scene.drawStyle.IDENT); gl.glPopMatrix(); /* ----- TOP FACE ----- */ gl.glPushMatrix(); gl.glViewport( 0, (drawable.getHeight() / 3) + (drawable.getHeight() / 6), drawable.getWidth(), drawable.getHeight() / 6); gl.glMatrixMode(gl.GL_PROJECTION); gl.glLoadIdentity(); gl.glFrustum(-near, near, -near, 0, near, far); /* Position camera at center of specified patch (which) */ gl.glMatrixMode(gl.GL_MODELVIEW); gl.glLoadIdentity(); glu.gluLookAt( centerPoint.x, centerPoint.y, centerPoint.z, centerPoint.x + vec1.x, centerPoint.y + vec1.y, centerPoint.z + vec1.z, centerPoint.x - norm.x, centerPoint.y - norm.y, centerPoint.z - norm.z); /* Draw the frustum to screen */ draw(drawable, scene.drawStyle.IDENT); gl.glPopMatrix(); /* ----- LEFT FACE ----- */ gl.glPushMatrix(); gl.glViewport( 0, (drawable.getHeight() / 3) + 2 * (drawable.getHeight() / 6), drawable.getWidth(), drawable.getHeight() / 6); gl.glMatrixMode(gl.GL_PROJECTION); gl.glLoadIdentity(); gl.glFrustum(0, near, -near, near, near, far); /* Position camera at center of specified patch (which) */ gl.glMatrixMode(gl.GL_MODELVIEW); gl.glLoadIdentity(); glu.gluLookAt( centerPoint.x, centerPoint.y, centerPoint.z, centerPoint.x + vec2.x, centerPoint.y + vec2.y, centerPoint.z + vec2.z, centerPoint.x + vec1.x, centerPoint.y + vec1.y, centerPoint.z + vec1.z); /* Draw the frustum to screen */ draw(drawable, scene.drawStyle.IDENT); gl.glPopMatrix(); /* ----- RIGHT FACE ----- */ gl.glPushMatrix(); gl.glViewport( 0, (drawable.getHeight() / 3) + 3 * (drawable.getHeight() / 6), drawable.getWidth(), drawable.getHeight() / 6); gl.glMatrixMode(gl.GL_PROJECTION); gl.glLoadIdentity(); gl.glFrustum(near, 0, -near, near, near, far); /* Position camera at center of specified patch (which) */ gl.glMatrixMode(gl.GL_MODELVIEW); gl.glLoadIdentity(); glu.gluLookAt( centerPoint.x, centerPoint.y, centerPoint.z, centerPoint.x + (-vec2.x), centerPoint.y + (-vec2.y), centerPoint.z + (-vec2.z), centerPoint.x + vec1.x, centerPoint.y + vec1.y, centerPoint.z + vec1.z); /* Draw the frustum to screen */ draw(drawable, scene.drawStyle.IDENT); gl.glPopMatrix(); /* ---- End Frustums ---- */ // if collecting the form factors, then read back and process the data if (bCollect) { gl.glFlush(); gl.glFinish(); gl.glReadPixels( 0, 0, divisions * 2, divisions * 6, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, pixelDataBuffer); collectData(which); } }
private void init(final Content c, final int x, final int y) { xLast = x; yLast = y; content = c; // some transforms c.getLocalToVworld(localToVWorld); localToVWorldInverse.invert(localToVWorld); canvas.getImagePlateToVworld(ipToVWorld); ipToVWorldInverse.invert(ipToVWorld); // calculate the canvas position in world coords c.getContent().getCenter(centerInVWorld); localToVWorld.transform(centerInVWorld); ipToVWorldInverse.transform(centerInVWorld, centerInIp); // get the eye point in world coordinates canvas.getCenterEyeInImagePlate(eyePtInVWorld); ipToVWorld.transform(eyePtInVWorld); // use picking to infer the radius of the virtual sphere which is rotated final Point3d p = univ.getPicker().getPickPointGeometry(c, x, y); float r = 0, dD = 0; if (p != null) { pickPtInVWorld.set(p); localToVWorld.transform(pickPtInVWorld); r = (float) pickPtInVWorld.distance(centerInVWorld); } else { c.getContent().getMin(p1); localToVWorld.transform(p1); r = (float) p1.distance(centerInVWorld); vec.sub(centerInVWorld, eyePtInVWorld); vec.normalize(); vec.scale(-r); pickPtInVWorld.add(centerInVWorld, vec); } dD = (float) pickPtInVWorld.distance(eyePtInVWorld); // calculate distance between eye and canvas point canvas.getPixelLocationInImagePlate(x, y, p1); ipToVWorld.transform(p1); final float dd = (float) p1.distance(eyePtInVWorld); // calculate the virtual distance between two neighboring pixels canvas.getPixelLocationInImagePlate(x + 1, y, p2); ipToVWorld.transform(p2); final float dx = (float) p1.distance(p2); // calculate the virtual distance between two neighboring pixels canvas.getPixelLocationInImagePlate(x, y + 1, p3); ipToVWorld.transform(p3); final float dy = (float) p1.distance(p3); final float dX = dD / dd * dx; final float dY = dD / dd * dy; anglePerPix = Math.atan2(dX, r); univ.getViewPlatformTransformer().getYDir(axisPerDx, ipToVWorld); univ.getViewPlatformTransformer().getXDir(axisPerDy, ipToVWorld); translationPerDx.set(axisPerDy); translationPerDx.scale(dX); translationPerDy.set(axisPerDx); translationPerDy.scale(dY); rotateTG = c.getLocalRotate(); translateTG = c.getLocalTranslate(); c.getContent().getCenter(vec); transl_inv.set(vec); vec.set(-vec.x, -vec.y, -vec.z); transl.set(vec); }