public Point3d toCenterCoordinates(final Point3d point) { Point3d transformed = new Point3d(point); reverseCenterTransform.transform(transformed); return transformed; }
public Vector3d toCenterCoordinates(final Vector3d vector) { Vector3d transformed = new Vector3d(vector); reverseCenterTransform.transform(transformed); return transformed; }
public Vector3d toBoxCoordinates(final Vector3d vector) { Vector3d transformed = new Vector3d(vector); reverseTransform.transform(transformed); return transformed; }
public Point3d toBoxCoordinates(final Point3d point) { Point3d transformed = new Point3d(point); reverseTransform.transform(transformed); return transformed; }
/** * Rotates a given point around the origin. * @param p the point to rotate * @param rot the rotation as axis-angle (x,y,z,angle) */ public static void rotate(Point3d p, AxisAngle4d rot) { Transform3D t3d = new Transform3D(); t3d.setRotation(rot); t3d.transform(p); }
private float[] exportCoords( GeometryArray ga, Transform3D transformation, double[] lower, double[] upper ) { float[] coords = new float[ga.getVertexCount() * 3]; ga.getCoordinates( ga.getInitialVertexIndex(), coords ); boolean doSceneTransform = ( transformation != null && transformation.getBestType() != Transform3D.IDENTITY ); for ( int i = 0; ( i + 2 ) < coords.length; i += 3 ) { Point3d coord = new Point3d( coords[i], coords[i + 1], coords[i + 2] ); // if ( doUserRotation ) { // userRotationMatrix.transform( coord ); // } if ( doSceneTransform ) { transformation.transform( coord ); } if ( doUserTransform ) { userMatrix.transform( coord ); } coords[i] = (float) coord.x; coords[i + 1] = (float) coord.y; coords[i + 2] = (float) coord.z; upper[0] = max( coords[i], upper[0] ); upper[1] = max( coords[i + 1], upper[1] ); upper[2] = max( coords[i + 2], upper[2] ); lower[0] = min( coords[i], lower[0] ); lower[1] = min( coords[i + 1], lower[1] ); lower[2] = min( coords[i + 2], lower[2] ); } return coords; }
/** * Gets the center coordinates of the unit's BoundingBox in the coordinate system of the root location as a Point3d object. * * @param unitConfig the unit config to refer the unit. * @return center coordinates of the unit's BoundingBox relative to root location * @throws NotAvailableException is thrown if the center can not be calculate. */ default Point3d getUnitBoundingBoxCenterGlobalPoint3d(final UnitConfig unitConfig) throws NotAvailableException { try { final Transform3D transformation = getUnitToRootTransform3D(unitConfig); final Point3d center = getUnitBoundingBoxCenterPoint3d(unitConfig); transformation.transform(center); return center; } catch (NotAvailableException ex) { throw new NotAvailableException("GlobalBoundingBoxCenter", ex); } }
private void translate(float x, float y, float z) { Set<Node> alreadyConverted = new HashSet<Node>(); Transform3D t3d = new Transform3D(); t3d.setScale(scale); t3d.setTranslation(new Vector3f(x, y, z)); for (Triangle t : getGeometry()) { if (!alreadyConverted.contains(t.getNodeOne())) { t3d.transform(t.getNodeOne().getLocation()); alreadyConverted.add(t.getNodeOne()); } if (!alreadyConverted.contains(t.getNodeTwo())) { t3d.transform(t.getNodeTwo().getLocation()); alreadyConverted.add(t.getNodeTwo()); } if (!alreadyConverted.contains(t.getNodeThree())) { t3d.transform(t.getNodeThree().getLocation()); alreadyConverted.add(t.getNodeThree()); } } } }
/** * Returns the global coordinates of a given transform object. * @param t3d the transform object * @param globalT3d the local coordinates to virtual world coordinates * transform object * @return the global coordinates of the specified transform object */ public static Point3d getGlobalCoordinates( Transform3D t3d, Transform3D globalT3d) { Point3d result = new Point3d(); Vector3d transVec = new Vector3d(); t3d.get(transVec); result.set(transVec); globalT3d.transform(result); return result; }
public void transformChanged(int type, TransformGroup tg) { if(tg == null) return; Transform3D t3d = new Transform3D(); tg.getTransform(t3d); // System.err.println(tg+" transformChanged \n"+t3d); Point3f p1 = new Point3f(); V v = vertexMap.getKey(tg); // Transform3D lvw = new Transform3D(); // tg.getLocalToVworld(lvw); // System.err.println("lvw = \n"+lvw); // lvw.invert(); // System.err.println("invert lvw = \n"+lvw); Point3f p0 = layout.transform(v); // Transform3D vwip = new Transform3D(); // canvas.getVworldToImagePlate(vwip); // System.err.println("vwip=\n"+vwip); // t3d.mul(lvw); t3d.transform(p1); // scale.transform(p1); System.err.println("change location for vertex "+v+", transformGroup "+tg+" from "+p0+" to "+p1); // p1.set(p1.getX()*2,p1.getY()*2,p1.getZ()*2); // layout.setLocation(v, p1); }});
/** * Sets the height of the vector to the default height in root coordinates, * then transforms it back to unit coordinates. * * @param vector original vector in unit coordinates. * @param transform transform from root to unit coordinates. * @param inverseTransform transform from unit to root coordinates. * @return Transformed original vector in unit coordinates. */ private Vec3DDouble addHeight(final Vec3DDouble vector, final Transform3D transform, final Transform3D inverseTransform) { Vector3d vector3d = new Vector3d(vector.getX(), vector.getY(), vector.getZ()); inverseTransform.transform(vector3d); vector3d.z += DEFAULT_HEIGHT; transform.transform(vector3d); return Vec3DDouble.newBuilder().setX(vector3d.x).setY(vector3d.y).setZ(vector3d.z).build(); } }
private Vector3D relToAbs (Vector3D r) { Transform3D t = getTransform(); Matrix3d m = new Matrix3d(); t.get(m); Vector3d zero = new Vector3d(0, 0, 0); Transform3D rotation = new Transform3D(m, zero, 1.0); Vector3f vec = createVector3f(r); rotation.transform(vec); return new Vector3D(vec); }
private Vector3D relToAbs (Vector3D r) { Transform3D t = getTransform(); Matrix3d m = new Matrix3d(); t.get(m); Vector3d zero = new Vector3d(0, 0, 0); Transform3D rotation = new Transform3D(m, zero, 1.0); Vector3f vec = createVector3f(r); rotation.transform(vec); return new Vector3D(vec); }
private Vector3D absToRel (Vector3D r) { Transform3D t = getTransform(); Matrix3d m = new Matrix3d(); t.get(m); Vector3d zero = new Vector3d(0, 0, 0); Transform3D rotation = new Transform3D(m, zero, 1.0); Vector3f vec = createVector3f(r); rotation.invert(); rotation.transform(vec); return new Vector3D(vec); }
private Vector3D absToRel (Vector3D r) { Transform3D t = getTransform(); Matrix3d m = new Matrix3d(); t.get(m); Vector3d zero = new Vector3d(0, 0, 0); Transform3D rotation = new Transform3D(m, zero, 1.0); Vector3f vec = createVector3f(r); rotation.invert(); rotation.transform(vec); return new Vector3D(vec); }
@Override public List<UnitConfig> getLocationConfigsByCoordinate(Vec3DDoubleType.Vec3DDouble coordinate, LocationConfig.LocationType locationType) throws CouldNotPerformException, InterruptedException, ExecutionException { List<UnitConfig> result = new ArrayList<>(); for (UnitConfig unitConfig : locationUnitConfigRemoteRegistry.getMessages()) { // Check if the unit meets the requirements of the filter if (!locationType.equals(LocationConfig.LocationType.UNKNOWN) && !locationType.equals(unitConfig.getLocationConfig().getType())) { continue; } // Get the shape of the floor List<Vec3DDoubleType.Vec3DDouble> floorList = unitConfig.getPlacementConfig().getShape().getFloorList(); // Convert the shape into a PolygonsSet List<Vector2D> vertices = floorList.stream() .map(vec3DDouble -> new Vector2D(vec3DDouble.getX(), vec3DDouble.getY())) .collect(Collectors.toList()); PolygonsSet polygonsSet = new PolygonsSet(0.1, vertices.toArray(new Vector2D[]{})); // Transform the given coordinate Transform3D unitTransform = getRootToUnitTransformationFuture(unitConfig).get().getTransform(); Point3d transformedCoordinate = new Point3d(coordinate.getX(), coordinate.getY(), coordinate.getZ()); unitTransform.transform(transformedCoordinate); // NOTE: Hence apache-math builds its polygons counter clockwise unlike bco, the resulting polygon is inverted. // Therefore we check whether the point lies on the outside of the polygon. if (polygonsSet.checkPoint(new Vector2D(transformedCoordinate.x, transformedCoordinate.y)) == Location.OUTSIDE) { result.add(unitConfig); } } return result; }
unitTransform.transform(transformedCoordinate);
private void calculateCenters() { localCenter = new Point3d(boxVector); localCenter.scale(0.5); rootCenter = new Point3d(localCenter); forwardTransform.transform(rootCenter); forwardCenterTransform = new Transform3D(forwardTransform); forwardCenterTransform.mul(toTransform(new Vector3d(localCenter))); reverseCenterTransform = new Transform3D(forwardCenterTransform); reverseCenterTransform.invert(); }
transGroupTransform.transform(vec);
/** * Transforms the argument to root coordinates. * * @param translation translation that shall be transformed. * @return The transformed <code>translation</code> argument. */ private Translation transformPosition(Translation translation) { Translation.Builder transformedTranslation = translation.toBuilder().clone().clearX().clearY().clearZ(); if (translation.hasX() && translation.hasY() && translation.hasZ()) { Point3d point = new Point3d(-translation.getX(), -translation.getY(), translation.getZ()); transform.transform(point); transformedTranslation.setX(point.x).setY(point.y).setZ(point.z); } return transformedTranslation.build(); }