pyonics 0.0.1__py3-none-any.whl

pyonics/main.py

@@ -0,0 +1,71 @@
+# For building powered human augmentations.
+
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Oct 11 21:55:28 2022
+===============
+Document Comments:
+    10.11.22
+    2218h
+    I think the index should be separate from the time values. Physics should
+    be based on time independent of the index so that I can have a consistent
+    indexing scheme regardless of the time resolution of the data.
+
+    11.3.22
+    0944h
+    Interface is mostly done. Needs the graph to actually be updating inside
+    the desktopGUI but otherwise the front end is ready for a presentation. Adding
+    the fractional calculus functionality will be next.
+
+    12.2.22
+    2021h
+    Trying to refactor into smaller pieces.
+
+    11.23.23
+    0145h
+    Lots of progress been made.
+===============
+LIBRARY IMPORTS
+===============
+"""
+
+# Local Submodules
+
+import submodules.ui.interface as interface
+
+# External Libraries
+
+import pandas as pd
+import matplotlib.pyplot as plt
+
+"""
+CONFIG
+"""
+# pandas options
+pd.options.display.width = 0
+pd.set_option("display.max_columns", None)
+pd.set_option("display.max_rows", None)
+pd.set_option("display.width", None)
+pd.set_option("display.max_colwidth", None)
+
+# pyplot options
+plt.ion()
+
+
+"""
+CLASS DEFINITIONS
+"""
+
+"""
+FUNCTION DEFINITIONS
+"""
+
+
+def main(ui_type="AR"):
+    if ui_type == "AR":
+        ui = interface.AugmentOverlayTkUI()
+    else:
+        return
+
+if __name__ == "__main__":
+    main()

pyonics/meta.yaml

@@ -0,0 +1,33 @@
+package:
+  name: pyonics
+  version: "0.1.0"
+
+source:
+  path: .
+
+build:
+  number: 1
+  script: python -m pip install --no-deps --ignore-installed .
+
+requirements:
+  build:
+    - "python"
+    - "setuptools"
+    - "klampt"
+    - "numpy"
+    - "matplotlib"
+    - "matplotlib.pyplot"
+    - "pandas"
+
+  run:
+    - "python"
+    - "klampt"
+    - "numpy"
+    - "matplotlib"
+    - "matplotlib.pyplot"
+    - "pandas"
+    # Add any runtime dependencies here
+
+about:
+  home: https://github.com/pyromakesmusic/MATH4157/pyonics
+  license: LicenseName  # Replace with your license

pyonics/setup.py

@@ -0,0 +1,25 @@
+from setuptools import setup, find_packages
+import klampt
+import numpy
+import matplotlib
+import matplotlib.pyplot
+import pandas
+import submodules.apps
+import submodules.video
+import submodules.audio
+import submodules.control
+import submodules.ui
+
+
+setup(
+    name='pyonics',
+    version='0.1.0',
+    packages=find_packages(),
+    install_requires=[klampt,
+                      numpy,
+                      matplotlib,
+                      pandas
+
+        # List your dependencies here
+    ],
+)

pyonics/submodules/apps/apps.py

@@ -0,0 +1,240 @@
+import asyncio  # Needs asynchronous functionality
+import pandas as pd
+import gpsd  # GPS library
+# import cv2  # CameraWidget library
+from datetime import datetime
+import asyncio
+# Klamp't imports
+
+import klampt
+import klampt.model.coordinates
+import klampt.model.collide
+import klampt.model.contact
+import klampt.plan.robotplanning
+import klampt.plan.robotcspace
+import klampt.plan.cspace
+import klampt.plan.rigidobjectcspace
+
+# Each app should be its own class
+
+"""
+CLASSES
+"""
+
+# HUD Widgets
+class Map(klampt.vis.glcommon.GLProgram):
+    def __init__(self, widget=None):
+        self.world = klampt.WorldModel()
+        self.frenet = klampt.model.coordinates.Frame("frenet frame", self.world)
+        self.latitude = None
+        self.longitude = None
+        self.altitude = None
+
+        self.bearing = "east"
+        self.widget = widget
+        self.get_gps_data()
+        klampt.vis.glprogram.GLProgram.__init__(self)
+
+    async def surrounding_geometry(self):
+        pass
+
+
+    def get_gps_data(self):
+        # Connect to the local gpsd service (default host and port)
+        try:
+            gpsd.connect()
+            # Get the GPS data
+            packet = gpsd.get_current()
+            # Check if the data is valid
+            if packet.mode >= 2:
+                self.latitude = packet.lat
+                self.longitude = packet.lon
+                self.altitude = packet.alt
+
+                return (f"Latitude: {self.latitude},\n Longitude: {self.longitude},\n Altitude: {self.altitude}")
+            else:
+                return ("No GPS fix")
+        except ConnectionRefusedError:
+
+            return("GPS Fix failed")
+
+    def update(self, bearing):
+        gpsd.connect()
+        # Get the GPS data
+        packet = gpsd.get_current()
+        # Check if the data is valid
+        if packet.mode >= 2:
+            self.latitude = packet.lat
+            self.longitude = packet.lon
+            self.altitude = packet.alt
+
+        self.bearing = bearing
+
+    def set_widget(self, widget):
+        self.widget = widget
+
+class Clock():
+    def __init__(self, widget=None, widget_type=None):
+        # Adds a clock
+        self.time = datetime.now().strftime("%H:%M:%S")
+        self.widget = widget
+        self.widget_type = widget_type
+    def update(self):
+        self.time = datetime.now().strftime("%H:%M:%S")
+        return self.time
+
+    def set_widget(self, widget, widget_type):
+        self.widget = widget
+        self.widget_type = widget_type
+
+class DateWidget:
+    def __init__(self):
+        # Adds a clock
+        self.date = datetime.now().strftime("%Y.%m.%d")
+        self.display = None
+    def update(self):
+        self.date = datetime.now().strftime("%Y.%m.%d")
+        return self.date
+
+class TextWidget:
+    def __init__(self):
+        # Adds a clock
+        self.text = "widget text"
+    def update(self, text):
+        self.text = text
+        return self.text
+
+# class CameraWidget(klampt.vis.glcommon.GLProgram):
+#     def __init__(self, i):
+#         klampt.vis.glcommon.GLProgram.__init__(self)
+#         # Launches with an index of a particular camera
+#         self.camera = None
+#         self.state = "minimized"  # Can also be "fullscreen", "windowed", "closed"
+#
+#         self.ret = None
+#         self.frame = None
+#         self.shutdown_flag = False
+#
+#
+#
+#
+#     def cam_launch(self, index):
+#         # Start the camera
+#         try:
+#             self.camera = cv2.VideoCapture(index)
+#         except:
+#             "Error: Exception launching camera input."
+#
+#         while not self.shutdown_flag:
+#             asyncio.run(self.cam_loop())
+#
+#     def cam_loop_synchronous(self):
+#         self.ret, self.frame = self.camera.read()
+#
+#         # Check if the frame was read successfully
+#         if not self.ret:
+#             print("Error: Could not read frame.")
+#
+#         # Display the frame
+#         cv2.imshow('Webcam', self.frame)
+#         return self.frame
+#
+#     async def cam_loop(self):
+#         self.ret, self.frame = self.camera.read()
+#
+#         # Check if the frame was read successfully
+#         if not self.ret:
+#             print("Error: Could not read frame.")
+#
+#
+#         # Display the frame
+#         cv2.imshow('Webcam', self.frame)
+#         return self.frame
+#
+#     def cam_shutdown(self):
+#         # Break the loop if the user presses the 'q' key
+#         if cv2.waitKey(1) & 0xFF == ord('q'):
+#             self.shutdown_flag = True
+
+# Desktop Applications
+
+"""
+Simulation
+"""
+class Sim(klampt.sim.simulation.SimpleSimulator):
+    """
+    This is a class for Simulations. It will contain the substepping logic where forces are applied to simulated objects.
+    """
+    def __init__(self, wm, robot, timestep, collisions=True):  # Setting collisions to True for testing ONLY
+        klampt.sim.simulation.SimpleSimulator.__init__(self, wm)
+        self.world = wm
+        self.dt = timestep
+
+        self.robotmodel = robot
+        self.link_transforms_start = [self.robotmodel.link(x).getTransform() for x in range(self.robotmodel.numLinks())]
+        self.link_transforms_end = None
+        self.link_transforms_diff = None
+
+        if collisions:
+            self.collider = klampt.model.collide.WorldCollider(self.world)
+            self.planner = klampt.plan
+        else:
+            self.collider = None
+
+    async def pressures_to_forces(self, muscle_objects, pressures, force_multiplier):
+        force_list = []  # Makes a new empty list... of tuples? Needs link number, force, and transform
+        i = 0
+        try:
+            for muscle in muscle_objects:
+                triplet_a, triplet_b = muscle.update_muscle(pressures[i])  # Updates muscles w/ OSC argument
+                force_list.append(triplet_a)
+                force_list.append(triplet_b)
+                i += 1
+        except IndexError:
+            force_list.append([0,0,0])
+            force_list.append([0,0,0])
+        force_series = pd.Series(force_list)
+        return force_series * force_multiplier
+
+    async def simLoop(self, force_list):
+        """
+        robot: A RobotModel.
+        force_list: Not sure what data structure, maybe a dataframe? name of muscle as index, with force and transform
+
+        Should possibly return a list of new transforms to be used for calculating stuff in the next time step.
+
+        """
+        self.link_transforms_start = [self.robotmodel.link(x).getTransform() for x in range(self.robotmodel.numLinks())]
+        """
+        Below is where we apply each force in the simulation.
+        """
+        for force in force_list:
+            link = self.body(self.robotmodel.link(force[0]))  # From the force info, gets the link to apply force
+            force_vector = force[1]  # Gets the force vector
+            transform = force[2]  # Gets the transform at which to apply force
+            link.applyForceAtLocalPoint(force_vector, transform)  # Applys the force
+
+        self.simulate(self.dt)
+        self.updateWorld()
+        if self.collider:
+            pass
+            #klampt.model.contact.world_contact_map(self.world, padding=0.1, kFriction=1, collider=self.collider)
+            #print(self.collider.collisions())
+        """
+        Maybe here is where we have to get the updated link transforms and return them as "sensor" feedback.
+        """
+        self.link_transforms_end = [self.robotmodel.link(x).getTransform() for x in range(self.robotmodel.numLinks())]
+
+        self.link_transforms_diff = [klampt.math.se3.error(self.link_transforms_start[x], self.link_transforms_end[x])
+                                for x in range(len(self.link_transforms_start))]  # Takes the Lie derivative from start -> end
+        return self.link_transforms_end  # I don't even know if we need to use this, depends on if we pass by ref or var
+
+    async def configure_sim(self):
+        """
+        Sets up the simulation to do whatever I want it to do.
+        """
+        self.setSetting("boundaryLayerCollisions", "1")
+        self.setSetting("rigidObjectCollisions", "1")
+        self.setSetting("robotSelfCollisions", "1")
+        self.setSetting("robotRobotCollisions", "1")
+        self.setSetting("instabilityPostCorrectionEnergy", "0.01")

pyonics/submodules/audio/recording.py

@@ -0,0 +1,21 @@
+import pyaudio
+import numpy as np
+
+CHUNK = 2**5
+RATE = 44100
+LEN = 10
+
+p = pyaudio.PyAudio()
+
+stream = p.open(format=pyaudio.paInt16, channels=1, rate=RATE, input=True, frames_per_buffer=CHUNK)
+player = p.open(format=pyaudio.paInt16, channels=1, rate=RATE, output=True, frames_per_buffer=CHUNK)
+
+
+for i in range(int(LEN*RATE/CHUNK)): #go for a LEN seconds
+    data = np.fromstring(stream.read(CHUNK),dtype=np.int16)
+    player.write(data,CHUNK)
+
+
+stream.stop_stream()
+stream.close()
+p.terminate()