From d43002952c4238f5c5f62f996eb670924dcbd7d7 Mon Sep 17 00:00:00 2001 From: Butterscotch! Date: Wed, 16 Feb 2022 23:52:24 -0500 Subject: [PATCH] Consolidate PoseFrames functionality & add documentation --- .../java/dev/slimevr/autobone/AutoBone.java | 27 +--- .../poserecorder/PoseFrameTracker.java | 8 + .../dev/slimevr/poserecorder/PoseFrames.java | 151 +++++++++++++++--- .../slimevr/poserecorder/PoseRecorder.java | 6 +- 4 files changed, 148 insertions(+), 44 deletions(-) diff --git a/src/main/java/dev/slimevr/autobone/AutoBone.java b/src/main/java/dev/slimevr/autobone/AutoBone.java index 18a43aeb2..6b5daecd0 100644 --- a/src/main/java/dev/slimevr/autobone/AutoBone.java +++ b/src/main/java/dev/slimevr/autobone/AutoBone.java @@ -61,7 +61,7 @@ public class AutoBone { public float positionErrorFactor = 0.0f; public float positionOffsetErrorFactor = 0.0f; - // TODO Needs much more work, probably going to rethink how the errors work to avoid this barely functional workaround @ButterscotchVanilla + // TODO Needs much more work, probably going to rethink how the errors work to avoid this barely functional workaround @ButterscotchV // For scaling distances, since smaller sizes will cause smaller distances //private float totalLengthBase = 2f; @@ -240,37 +240,14 @@ public class AutoBone { return length; } - public float getMaxHmdHeight(PoseFrames frames) { - float maxHeight = 0f; - for(TrackerFrame[] frame : frames) { - TrackerFrame hmd = TrackerUtils.findTrackerForBodyPosition(frame, TrackerPosition.HMD); - if(hmd != null && hmd.hasData(TrackerFrameData.POSITION) && hmd.position.y > maxHeight) { - maxHeight = hmd.position.y; - } - } - return maxHeight; - } - - public void processFrames(PoseFrames frames) { - processFrames(frames, -1f); - } - public void processFrames(PoseFrames frames, Consumer epochCallback) { processFrames(frames, -1f, epochCallback); } - public void processFrames(PoseFrames frames, float targetHeight) { - processFrames(frames, true, targetHeight); - } - public void processFrames(PoseFrames frames, float targetHeight, Consumer epochCallback) { processFrames(frames, true, targetHeight, epochCallback); } - public float processFrames(PoseFrames frames, boolean calcInitError, float targetHeight) { - return processFrames(frames, calcInitError, targetHeight, null); - } - public float processFrames(PoseFrames frames, boolean calcInitError, float targetHeight, Consumer epochCallback) { final int frameCount = frames.getMaxFrameCount(); @@ -290,7 +267,7 @@ public class AutoBone { LogManager.log.warning("[AutoBone] Target height loaded from skeleton (Make sure you reset before running!): " + targetHeight); } else { // Otherwise if there is no skeleton available, attempt to get the max HMD height from the recording - float hmdHeight = getMaxHmdHeight(frames); + float hmdHeight = frames.getMaxHmdHeight(); if(hmdHeight <= 0.50f) { LogManager.log.warning("[AutoBone] Max headset height detected (Value seems too low, did you not stand up straight while measuring?): " + hmdHeight); } else { diff --git a/src/main/java/dev/slimevr/poserecorder/PoseFrameTracker.java b/src/main/java/dev/slimevr/poserecorder/PoseFrameTracker.java index d2a1dd911..220e57f87 100644 --- a/src/main/java/dev/slimevr/poserecorder/PoseFrameTracker.java +++ b/src/main/java/dev/slimevr/poserecorder/PoseFrameTracker.java @@ -31,10 +31,18 @@ public class PoseFrameTracker implements Tracker, Iterable { public PoseFrameTracker(String name, int initialCapacity) { this(name, new FastList(initialCapacity)); } + + public PoseFrameTracker(Tracker parent, int initialCapacity) { + this(parent.getName(), initialCapacity); + } public PoseFrameTracker(String name) { this(name, 5); } + + public PoseFrameTracker(Tracker parent) { + this(parent.getName()); + } private int limitCursor() { if(frameCursor < 0 || frames.isEmpty()) { diff --git a/src/main/java/dev/slimevr/poserecorder/PoseFrames.java b/src/main/java/dev/slimevr/poserecorder/PoseFrames.java index 88a4441a4..787fce901 100644 --- a/src/main/java/dev/slimevr/poserecorder/PoseFrames.java +++ b/src/main/java/dev/slimevr/poserecorder/PoseFrames.java @@ -4,63 +4,136 @@ import java.util.Iterator; import java.util.List; import java.util.NoSuchElementException; -import dev.slimevr.vr.trackers.Tracker; +import dev.slimevr.vr.trackers.TrackerPosition; +import dev.slimevr.vr.trackers.TrackerUtils; import io.eiren.util.collections.FastList; public final class PoseFrames implements Iterable { private final FastList trackers; + /** + * Creates a {@link PoseFrames} object with the provided list of {@link PoseFrameTracker}s as the internal {@link PoseFrameTracker} list + * @see {@link FastList}, {@link PoseFrameTracker} + */ public PoseFrames(FastList trackers) { this.trackers = trackers; } + /** + * Creates a {@link PoseFrames} object with the specified initial tracker capacity + * @see {@link #PoseFrames(FastList)} + */ public PoseFrames(int initialCapacity) { this.trackers = new FastList(initialCapacity); } + /** + * Creates a {@link PoseFrames} object with the default initial tracker capacity of {@code 5} + * @see {@link #PoseFrames(int)} + */ public PoseFrames() { this(5); } + /** + * Adds the provided {@link PoseFrameTracker} into the internal {@link PoseFrameTracker} list + * @return The {@link PoseFrameTracker} provided + * @see {@link List#add(Object)}, {@link PoseFrameTracker} + */ public PoseFrameTracker addTracker(PoseFrameTracker tracker) { trackers.add(tracker); return tracker; } - public PoseFrameTracker addTracker(Tracker tracker, int initialCapacity) { - return addTracker(new PoseFrameTracker(tracker.getName(), initialCapacity)); - } - - public PoseFrameTracker addTracker(Tracker tracker) { - return addTracker(tracker, 5); - } - + /** + * Removes the {@link PoseFrameTracker} at the specified index from the internal {@link PoseFrameTracker} list + * @return The {@link PoseFrameTracker} previously at the specified index + * @see {@link List#remove(int)}, {@link PoseFrameTracker} + */ public PoseFrameTracker removeTracker(int index) { return trackers.remove(index); } - public PoseFrameTracker removeTracker(PoseFrameTracker tracker) { - trackers.remove(tracker); - return tracker; + /** + * Removes the specified {@link PoseFrameTracker} from the internal {@link PoseFrameTracker} list + * @return {@code true} if the internal {@link PoseFrameTracker} list contained the specified {@link PoseFrameTracker} + * @see {@link List#remove(Object)}, {@link PoseFrameTracker} + */ + public boolean removeTracker(PoseFrameTracker tracker) { + return trackers.remove(tracker); } + /** + * Clears the internal {@link PoseFrameTracker} list + * @see {@link List#clear()}, {@link PoseFrameTracker} + */ public void clearTrackers() { trackers.clear(); } - + + /** + * Fake clears the internal {@link PoseFrameTracker} list by setting the size to zero + * @see {@link FastList#fakeClear()}, {@link PoseFrameTracker} + */ public void fakeClearTrackers() { trackers.fakeClear(); } + /** + * @return The number of contained {@link PoseFrameTracker} objects + * @see {@link List#size()}, {@link PoseFrameTracker} + */ public int getTrackerCount() { return trackers.size(); } + /** + * @return A list of the contained {@link PoseFrameTracker} objects + * @see {@link List}, {@link PoseFrameTracker} + */ public List getTrackers() { return trackers; } + + //#region Data Utilities + /** + * A utility function to get the maximum Y value of the tracker associated with the {@link TrackerPosition#HMD} tracker position + * @return The maximum Y value of the tracker associated with the {@link TrackerPosition#HMD} tracker position + * @see {@link #getMaxHeight(TrackerPosition)}, {@link TrackerPosition#HMD} + */ + public float getMaxHmdHeight() { + return getMaxHeight(TrackerPosition.HMD); + } + + /** + * A utility function to get the maximum Y value of the tracker associated with the specified {@link TrackerPosition} + * @return The maximum Y value of the tracker associated with the specified {@link TrackerPosition} + * @see {@link TrackerPosition} + */ + public float getMaxHeight(TrackerPosition trackerPosition) { + float maxHeight = 0f; + + PoseFrameTracker hmd = TrackerUtils.findTrackerForBodyPosition(trackers, trackerPosition); + + if(hmd == null) { + return maxHeight; + } + + for(TrackerFrame frame : hmd) { + if (frame.hasData(TrackerFrameData.POSITION) && frame.position.y > maxHeight) { + maxHeight = frame.position.y; + } + } + + return maxHeight; + } + //#endregion + /** + * @return The maximum number of {@link TrackerFrame}s contained within each {@link PoseFrameTracker} in the internal {@link PoseFrameTracker} list + * @see {@link PoseFrameTracker#getFrameCount()}, {@link PoseFrameTracker} + */ public int getMaxFrameCount() { int maxFrames = 0; @@ -73,23 +146,65 @@ public final class PoseFrames implements Iterable { return maxFrames; } - + + /** + * Using the provided array buffer, get the {@link TrackerFrame}s contained within each {@link PoseFrameTracker} in the internal {@link PoseFrameTracker} list at the specified index + * @return The number of frames written to the buffer + * @see {@link PoseFrameTracker#safeGetFrame(int)}, {@link TrackerFrame}, {@link PoseFrameTracker} + */ public int getFrames(int frameIndex, TrackerFrame[] buffer) { + int frameCount = 0; + for(int i = 0; i < trackers.size(); i++) { PoseFrameTracker tracker = trackers.get(i); - buffer[i] = tracker != null ? tracker.safeGetFrame(frameIndex) : null; + + if (tracker == null) { + continue; + } + + TrackerFrame frame = tracker.safeGetFrame(frameIndex); + + if (frame == null) { + continue; + } + + buffer[frameCount++] = frame; } - return trackers.size(); + + return frameCount; } + /** + * Using the provided {@link List} buffer, get the {@link TrackerFrame}s contained within each {@link PoseFrameTracker} in the internal {@link PoseFrameTracker} list at the specified index + * @return The number of frames written to the buffer + * @see {@link PoseFrameTracker#safeGetFrame(int)}, {@link List#set(int, Object)}, {@link TrackerFrame}, {@link PoseFrameTracker} + */ public int getFrames(int frameIndex, List buffer) { + int frameCount = 0; + for(int i = 0; i < trackers.size(); i++) { PoseFrameTracker tracker = trackers.get(i); - buffer.add(i, tracker != null ? tracker.safeGetFrame(frameIndex) : null); + + if (tracker == null) { + continue; + } + + TrackerFrame frame = tracker.safeGetFrame(frameIndex); + + if (frame == null) { + continue; + } + + buffer.set(frameCount++, frame); } - return trackers.size(); + + return frameCount; } + /** + * @return The {@link TrackerFrame}s contained within each {@link PoseFrameTracker} in the internal {@link PoseFrameTracker} list at the specified index + * @see {@link PoseFrameTracker#safeGetFrame(int)}, {@link TrackerFrame}, {@link PoseFrameTracker} + */ public TrackerFrame[] getFrames(int frameIndex) { TrackerFrame[] trackerFrames = new TrackerFrame[trackers.size()]; getFrames(frameIndex, trackerFrames); diff --git a/src/main/java/dev/slimevr/poserecorder/PoseRecorder.java b/src/main/java/dev/slimevr/poserecorder/PoseRecorder.java index 42fdbed27..6b5e99c00 100644 --- a/src/main/java/dev/slimevr/poserecorder/PoseRecorder.java +++ b/src/main/java/dev/slimevr/poserecorder/PoseRecorder.java @@ -112,8 +112,12 @@ public class PoseRecorder { continue; } + // Create a tracker recording + PoseFrameTracker poseFrameTracker = new PoseFrameTracker(tracker, numFrames); + poseFrame.addTracker(poseFrameTracker); + // Pair tracker with recording - this.trackers.add(Pair.of(tracker, poseFrame.addTracker(tracker, numFrames))); + this.trackers.add(Pair.of(tracker, poseFrameTracker)); } this.frameCursor = 0;