private int findPointOfMinMov(int start_, int end_, int fileIndex) {
    //		logger.debug("Anfang: " + start_+ " Ende: " + end_);
    int start = start_;
    //		double sum = 	Math.pow(rawData.get(fileIndex).getDimension(0)[start],2) +
    //						Math.pow(rawData.get(fileIndex).getDimension(1)[start],2) +
    //						Math.pow(rawData.get(fileIndex).getDimension(2)[start],2);
    //		sum = Math.sqrt(sum);

    Point3d from =
        new Point3d(
            rawData.get(fileIndex).getDimension(0)[start],
            rawData.get(fileIndex).getDimension(1)[start],
            rawData.get(fileIndex).getDimension(2)[start]);
    int minMovIndex = start;

    while (start != end_) { // mean of difference of acceleration to fixed point
      Point3d tempPoint =
          new Point3d(
              rawData.get(fileIndex).getDimension(0)[start],
              rawData.get(fileIndex).getDimension(1)[start],
              rawData.get(fileIndex).getDimension(2)[start]);
      //			tempSum = Math.sqrt(tempSum);
      //			if ((sum - tempSum > 0)){
      //			sum = tempSum;
      if (from.distance(tempPoint) < 0.2) {
        minMovIndex = start;
        //			logger.debug("summe: " +minMovIndex);
      }
      start++;
    }
    return minMovIndex;
  }
 /*
  * Bottom up hierarchical clustering
  */
 private static HashSet<Cluster> findClusters(Collection<Point3d> points, double threshold) {
   HashSet<Cluster> clusters = new HashSet<>(points.size() * 2);
   for (Point3d p : points) {
     Cluster candidate = new Cluster();
     candidate.add(p);
     for (Point3d p2 : points) {
       if (p != p2 && p.distance(p2) <= threshold) {
         candidate.add(p2);
       }
     }
     Iterator<Cluster> iter = clusters.iterator();
     while (iter.hasNext()) {
       Cluster c = iter.next();
       for (Point3d p2 : candidate) {
         if (c.contains(p2)) { // Se os clusters C e candidate se intersectam, fundi-los
           candidate.addAll(c);
           iter.remove();
           break;
         }
       }
     }
     clusters.add(candidate);
   }
   return clusters;
 }
Esempio n. 3
0
 // generic method for calculation of distance btw 2 atoms
 private double calculateDistanceBetweenTwoAtoms(IAtom atom1, IAtom atom2) {
   double distance;
   Point3d firstPoint = atom1.getPoint3d();
   Point3d secondPoint = atom2.getPoint3d();
   distance = firstPoint.distance(secondPoint);
   return distance;
 }
Esempio n. 4
0
 // method which calculated distance btw an atom and the middle point of a bond
 // and returns distance and coordinates of middle point
 private double[] calculateDistanceBetweenAtomAndBond(IAtom proton, IBond theBond) {
   Point3d middlePoint = theBond.get3DCenter();
   Point3d protonPoint = proton.getPoint3d();
   double[] values = new double[4];
   values[0] = middlePoint.distance(protonPoint);
   values[1] = middlePoint.x;
   values[2] = middlePoint.y;
   values[3] = middlePoint.z;
   return values;
 }
Esempio n. 5
0
 /**
  * Tests if two positions are symmetrically equivalent under point group within a provided
  * tolerance.
  *
  * @param a First comparison Point3d.
  * @param b Second comparison Point3d
  * @param tolerance Tolerance distance
  * @return True if positions are equivalent, false otherwise.
  */
 public boolean isSymmetricallyEquivalent(Point3d a, Point3d b, double tolerance) {
   boolean isequivalent = false;
   for (SymmetryOperation key : operations) {
     Point3d testcoord = key.transformPoint(a);
     if (testcoord.distance(b) < tolerance) {
       isequivalent = true;
       break;
     }
   }
   return isequivalent;
 }
Esempio n. 6
0
 public boolean isValidList2Position(Vector3d position) {
   for (int i = 0; i < pcList2.size(); i++) {
     PointCharge pc = (PointCharge) pcList2.get(i);
     Point3d pcPosition = new Point3d(pc.getPosition());
     if (pcPosition.distance(new Point3d(position)) < pc_radius * 1.5) {
       return false;
     }
   }
   if (Math.abs(position.x - plate2_position.x) > plate_length / 2. - pc_radius) return false;
   if (Math.abs(position.y - plate2_position.y) > plate_height / 2. - pc_radius) return false;
   if (Math.abs(position.z - plate2_position.z) > plate_width / 2. - pc_radius) return false;
   return true;
 }
Esempio n. 7
0
  public void moveCamera() {
    try {
      cameraT3D.lookAt(cameraPos, cameraFocus, up);
      cameraT3D.invert();
      cameraTG.setTransform(cameraT3D);
      // lamp position at camera
      camLamp.setPosition(new Point3f(cameraPos));

      // camera distance to object
      camDist = cameraPos.distance(getObjCenter());

    } catch (SingularMatrixException ex) {
      ex.printStackTrace();
    }
  }
Esempio n. 8
0
 public boolean areSamePos(Point3d p1, Point3d p2) {
   return Math.abs(p1.distance(p2)) < epsilon;
 }
Esempio n. 9
0
    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);
    }
Esempio n. 10
0
  private MyPickResult getMouseIntersection(MouseEvent e, boolean withSnap) {

    MyPickResult myResult = new MyPickResult();

    Point3d closestObjectPos = null;
    Point3d closestMarkPos = null;
    Node closestObject = null;
    Node closestMark = null;

    // 0: closest object; 1: closest mark
    pickCanvas.setShapeLocation(e);
    PickResult[] allResults = null;
    try {
      allResults = pickCanvas.pickAllSorted();
    } catch (AssertionError ex) {
    }
    if (allResults != null) {
      for (PickResult result : allResults) {
        Shape3D s = (Shape3D) result.getNode(PickResult.SHAPE3D);
        if (s != null) { // only pick a Shape3D object
          if (closestObjectPos != null && closestMarkPos != null) {
            break;
          }
          try {
            PickIntersection intersection = result.getClosestIntersection(cameraPos);
            if (!(s.getParent().getParent().getParent() instanceof Mark)
                && !((s.getParent().getParent().getParent() instanceof Marker))) {
              // markdot/markline/label -> TG -> BG -> Mark/Marker
              try {
                closestObjectPos = intersection.getPointCoordinatesVW();
                closestObject = s;
              } catch (NullPointerException ex) {
              }
            } else if ((s.getParent().getParent().getParent() instanceof Mark)) {
              try {
                closestMarkPos = intersection.getPointCoordinatesVW();
                closestMark = s;
              } catch (NullPointerException ex) {
              }
            }
          } catch (NullPointerException ex) {
          }
        }
      }

      Point3d resultPos = null;
      Node resultNode = null;

      if (closestMark != null) {
        resultPos = closestMarkPos; // priority of result -> mark
        resultNode = closestMark;
      } else if (closestObject != null) {
        resultPos = closestObjectPos;
        resultNode = closestObject;
      }

      if (withSnap) { // snap resultPos to correct position

        // start trying to if cursor are inside object bounding sphere
        if ((closestObjectPos != null && bs.intersect(closestObjectPos))
            || closestMarkPos != null && bs.intersect(closestMarkPos)) {

          Point3d closestObjectPos2 = null;
          Point3d closestMarkPos2 = null;
          Node closestObject2 = null;
          Node closestMark2 = null;

          // initiate snap bounds if hasn't been initiated before
          // "snappable" targets to be considered are the ones inside threshold
          if (cursorBound == null) {
            cursorBound = new BoundingSphere(resultPos, CURSOR_THRESHOLD);
          }
          if (thresholdBound == null) {
            thresholdBound = new BoundingSphere(resultPos, SNAP_THRESHOLD);
          }

          // update the bounds
          // only if the cursor is no longer inside current cursor bounds
          if (!cursorBound.intersect(resultPos)) {
            cursorBound.setCenter(resultPos);
            thresholdBound.setCenter(resultPos);
          }

          // snap to nearest point in the list of snap targets
          double nearestDistance = FARTHEST;
          double distance;
          Point3d nearestTarget = null;

          // snap to vertex. all vertexes listed in snapList
          if (snapList.size() > 0) {
            for (Point3d snapTarget : snapList) {
              if (thresholdBound.intersect(snapTarget)) {
                distance = snapTarget.distance(resultPos);
                if (distance < nearestDistance) {
                  nearestDistance = distance;
                  nearestTarget = snapTarget;
                }

                if (nearestTarget != null) {
                  resultPos.set(nearestTarget); // snap!

                  // pick the snapped node
                  Vector3d camToSnapped = new Vector3d();
                  camToSnapped.x = resultPos.x - cameraPos.x;
                  camToSnapped.y = resultPos.y - cameraPos.y;
                  camToSnapped.z = resultPos.z - cameraPos.z;
                  pickCanvas.setShapeRay(cameraPos, camToSnapped);

                  PickResult[] allResultsSnapped = null;
                  try {
                    allResultsSnapped = pickCanvas.pickAllSorted();
                  } catch (AssertionError ex) {
                  }
                  if (allResultsSnapped != null) {
                    for (PickResult result : allResultsSnapped) {
                      Shape3D s = (Shape3D) result.getNode(PickResult.SHAPE3D);
                      if (s != null) { // only pick a Shape3D object
                        if (closestObjectPos2 != null && closestMarkPos2 != null) {
                          break;
                        }
                        try {
                          PickIntersection intersection = result.getClosestIntersection(cameraPos);
                          if (!(s.getParent().getParent().getParent() instanceof Mark)
                              && !((s.getParent().getParent().getParent() instanceof Marker))) {
                            // markdot/markline/label -> TG -> BG -> Mark/Marker
                            try {
                              closestObjectPos2 = intersection.getPointCoordinatesVW();
                              closestObject2 = s;
                            } catch (NullPointerException ex) {
                            }
                          } else if ((s.getParent().getParent().getParent() instanceof Mark)) {
                            try {
                              closestMarkPos2 = intersection.getPointCoordinatesVW();
                              closestMark2 = s;
                            } catch (NullPointerException ex) {
                            }
                          }
                        } catch (NullPointerException ex) {
                        }
                      }
                    }

                    if (closestMark2 != null) {
                      resultPos = closestMarkPos2; // priority of result -> mark
                      resultNode = closestMark2;
                    } else if (closestObject2 != null) {
                      resultPos = closestObjectPos2;
                      resultNode = closestObject2;
                    }
                  }
                }
              }
            }
          }
        }
      }

      myResult.setPoint(resultPos);
      myResult.setNode(resultNode);
    }
    return myResult;
  }