@After public void tearDown() { ReferenceFrameTools.clearWorldFrameTree(); }
/** * Use * {@link ReferenceFrameTools#constructFrameWithUnchangingTransformToParent(String, ReferenceFrame, RigidBodyTransform)} * instead. */ @Deprecated public static ReferenceFrame constructFrameWithUnchangingTransformToParent(String frameName, ReferenceFrame parentFrame, RigidBodyTransform transformToParent) { return ReferenceFrameTools.constructFrameWithUnchangingTransformToParent(frameName, parentFrame, transformToParent); } }
/** Use {@link ReferenceFrameTools#constructARootFrame(String)} instead. */ @Deprecated public static ReferenceFrame constructARootFrame(String frameName) { return ReferenceFrameTools.constructARootFrame(frameName); }
@Ignore @Test public void testUniqueNaming() { Random random = new Random(13L); ReferenceFrame someFrame = EuclidFrameRandomTools.nextReferenceFrame(random); String frameName = someFrame.getName(); ReferenceFrame parent = someFrame.getParent(); try { ReferenceFrameTools.constructFrameWithUnchangingTransformToParent(frameName, parent, new RigidBodyTransform()); fail("Should have thrown a RuntimeException"); } catch (RuntimeException e) { // good } ReferenceFrameTools.removeFrame(someFrame); someFrame = ReferenceFrameTools.constructFrameWithUnchangingTransformToParent(frameName, parent, new RigidBodyTransform()); someFrame.remove(); someFrame = ReferenceFrameTools.constructFrameWithUnchangingTransformToParent(frameName, parent, new RigidBodyTransform()); ReferenceFrameTools.clearFrameTree(someFrame); someFrame = ReferenceFrameTools.constructFrameWithUnchangingTransformToParent(frameName, parent, new RigidBodyTransform()); ReferenceFrameTools.clearWorldFrameTree(); ReferenceFrameTools.constructFrameWithUnchangingTransformToParent(frameName, parent, new RigidBodyTransform()); }
ReferenceFrame world = ReferenceFrameTools.getWorldFrame(); ReferenceFrame constantFrame = ReferenceFrameTools.constructFrameWithUnchangingTransformToParent("constant" + i, world, expected); ReferenceFrame constantFrame = ReferenceFrameTools.constructFrameWithUnchangingTransformFromParent("constant" + i, world, expected); expected.invert();
/** * @return the root frame of the world reference frame tree. * @see ReferenceFrameTools#getWorldFrame() */ public static ReferenceFrame getWorldFrame() { return ReferenceFrameTools.getWorldFrame(); }
/** * Use * {@link ReferenceFrameTools#constructFrameWithUnchangingTransformFromParent(String, ReferenceFrame, RigidBodyTransform)} * instead. */ @Deprecated public static ReferenceFrame constructFrameWithUnchangingTransformFromParent(String frameName, ReferenceFrame parentFrame, RigidBodyTransform transformFromParent) { return ReferenceFrameTools.constructFrameWithUnchangingTransformFromParent(frameName, parentFrame, transformFromParent); }
/** * Will remove all provided frames from the frame tree. * * @param frames to be removed and disabled. * @see ReferenceFrameTools#removeFrame(ReferenceFrame) * @deprecated Reference frames are automatically disposed of by the GC when no external reference * exists. * @since 0.9.4 */ @Deprecated public static void removeFrames(ReferenceFrame[] frames) { for (int frameIdx = 0; frameIdx < frames.length; frameIdx++) { removeFrame(frames[frameIdx]); } }
/** * Tests if this reference frame is {@link #getWorldFrame()}. * * @return {@code true} if this is {@link #getWorldFrame()}, {@code false} otherwise. */ public boolean isWorldFrame() { checkIfRemoved(); return this == ReferenceFrameTools.getWorldFrame(); }
/** * Generates a reference frame with a random transform to its parent frame. * * @param frameName the name of the new frame. * @param random the random generator to use. * @param parentFrame the parent frame of the new reference frame. * @param use2DTransform whether to use a 2D or 3D rotation for the transform used to create the * random frame. * @return the new random reference frame. */ public static ReferenceFrame nextReferenceFrame(String frameName, Random random, ReferenceFrame parentFrame, boolean use2DTransform) { RigidBodyTransform transformFromParent; if (use2DTransform) transformFromParent = EuclidCoreRandomTools.nextRigidBodyTransform2D(random); else transformFromParent = EuclidCoreRandomTools.nextRigidBodyTransform(random); return ReferenceFrameTools.constructFrameWithUnchangingTransformFromParent(frameName, parentFrame, transformFromParent); }
@After public void tearDown() { ReferenceFrameTools.clearWorldFrameTree(); }
/** * Creates a reference frame with an immutable translation offset from its parent. * <p> * The new reference frame has the same orientation as its parent frame. * </p> * * @param frameName the name of the new frame. * @param parentFrame the parent frame of the new reference frame. * @param translationOffsetFromParent describes the position of the new reference frame's origin * expressed in the parent frame. Not modified. * @return the new reference frame. */ public static ReferenceFrame constructFrameWithUnchangingTranslationFromParent(String frameName, ReferenceFrame parentFrame, Tuple3DReadOnly translationOffsetFromParent) { RigidBodyTransform transformToParent = new RigidBodyTransform(); transformToParent.setTranslation(translationOffsetFromParent); return constructFrameWithUnchangingTransformToParent(frameName, parentFrame, transformToParent); }
ReferenceFrame anotherRoot = ReferenceFrameTools.constructARootFrame("anotherRoot");
/** * Returns the transform that can be used to transform a geometry object defined in this frame to * obtain its equivalent expressed in {@link #getWorldFrame()}. * <p> * WARNING: This method generates garbage. * </p> * * @return the transform from this frame to the {@link #getWorldFrame()}. */ public RigidBodyTransform getTransformToWorldFrame() { RigidBodyTransform ret = new RigidBodyTransform(); getTransformToDesiredFrame(ret, ReferenceFrameTools.getWorldFrame()); return ret; }
@After public void tearDown() { ReferenceFrameTools.clearWorldFrameTree(); }
/** * Creates a reference frame with an immutable transform from its parent. * <p> * The {@code transformFromParent} should describe the pose of the parent frame expressed in this * new frame. * </p> * * @param frameName the name of the new frame. * @param parentFrame the parent frame of the new reference frame. * @param transformFromParent the transform that can be used to transform a geometry object from the * parent frame to this frame. Not modified. * @return the new reference frame. */ public static ReferenceFrame constructFrameWithUnchangingTransformFromParent(String frameName, ReferenceFrame parentFrame, RigidBodyTransform transformFromParent) { RigidBodyTransform transformToParent = new RigidBodyTransform(transformFromParent); transformToParent.invert(); return constructFrameWithUnchangingTransformToParent(frameName, parentFrame, transformToParent); }
@Test public void testChangeFrame() throws Exception { Random random = new Random(43563); for (int i = 0; i < ITERATIONS; i++) { ReferenceFrame[] referenceFrames = EuclidFrameRandomTools.nextReferenceFrameTree(random, true); ReferenceFrame initialFrame = referenceFrames[random.nextInt(referenceFrames.length)]; ReferenceFrame anotherFrame = referenceFrames[random.nextInt(referenceFrames.length)]; Point2D expected = EuclidCoreRandomTools.nextPoint2D(random); FramePoint2D actual = new FramePoint2D(initialFrame, expected); RigidBodyTransform transform = initialFrame.getTransformToDesiredFrame(anotherFrame); expected.applyTransform(transform); actual.changeFrame(anotherFrame); assertTrue(anotherFrame == actual.getReferenceFrame()); EuclidCoreTestTools.assertTuple2DEquals(expected, actual, EPSILON); ReferenceFrame differentRootFrame = ReferenceFrameTools.constructARootFrame("anotherRootFrame"); try { actual.changeFrame(differentRootFrame); fail("Should have thrown a RuntimeException"); } catch (RuntimeException e) { // good } } }
@Test public void testUniqueFrameIndex() { Random random = new Random(84358345L); Set<Long> existingIds = new HashSet<>(); assertEquals(0L, ReferenceFrameTools.getWorldFrame().getFrameIndex()); existingIds.add(0L); for (int i = 0; i < ITERATIONS; i++) { ReferenceFrame[] frameTree = EuclidFrameRandomTools.nextReferenceFrameTree(random); for (ReferenceFrame referenceFrame : frameTree) { if (referenceFrame == ReferenceFrameTools.getWorldFrame()) { continue; } long frameIndex = referenceFrame.getFrameIndex(); assertFalse("Already has ID " + frameIndex, existingIds.contains(frameIndex)); existingIds.add(frameIndex); } } }
@After public void tearDown() { ReferenceFrameTools.clearWorldFrameTree(); }
intermediateFrames[dofIndex] = ReferenceFrameTools.constructFrameWithUnchangingTransformToParent(frameName, parentFrame, identity);