Fixed merge conflict

pyratk/acquisition/daq.py

@@ -53,6 +53,29 @@ class DAQ(QtCore.QThread):
         shape = (self.num_channels, self.sample_chunk_size)
         self.ts_buffer = TimeSeries(length, shape)
 
+    def sample_loop(self):
+        """Call get_samples forever."""
+        while self.running:
+            if self.paused:
+                # warning('(daq.py) daq paused...')
+                time.sleep(0.1)  # sleep 100 ms
+            else:
+                if self.daq_type == "FakeDAQ":
+                    self.get_fake_samples()
+                else:
+                    self.get_samples()
+
+                new_data = (self.data, self.sample_num)
+
+                # Set the update event to True once data is read in
+                self.data_available_signal.emit(new_data)
+                self.ts_buffer.append(self.data)
+
+                # Incriment sample number
+                self.sample_num += 1
+
+        print("Sampling thread stopped.")
+
     # === CONTROL =======================================================
     def close(self):
         self.running = False

pyratk/acquisition/data_mgr.py

@@ -327,7 +327,7 @@ class DataManager(MuxBuffer):
 
         # Add timestamp data per sample (to match NI readout)
         start = 0
-        step = self.source.sample_period
+        step = self.source.sample_interval
         stop = num_chunks * step
         sample_times = np.array([np.linspace(start, stop, new_data.shape[0])]).transpose()
 
@@ -346,7 +346,7 @@ class DataManager(MuxBuffer):
         header_1 = ('Timestamp', date_str) * num_channels
         header.append(','.join(header_1))
 
-        header_2 = ('Interval', str(self.source.sample_period))\
+        header_2 = ('Interval', str(self.source.sample_interval))\
                     * num_channels
         header.append(','.join(header_2))
 

pyratk/acquisition/synth_daq.py

@@ -69,7 +69,7 @@ class SynthDAQ(daq.DAQ):
         self.reset_flag = False
 
         # Fake sampler period
-        self.sample_chunk_period = self.sample_chunk_size / self.sample_rate
+        self.sample_chunk_period = self.sample_period = self.sample_chunk_size / self.sample_rate
 
         # Create data member to store samples
         self.data = None

pyratk/acquisition/virtual_daq.py

@@ -100,7 +100,7 @@ class VirtualDAQ(daq.DAQ):
             raise Exception('No dataset loaded.')
 
 
-    def get_samples(self, stride=1, loop=-1, playback_speed=0.25):
+    def get_samples(self, stride=1, loop=-1, playback_speed=0.5):
         """Read sample from dataset at sampled speed, or one-by-one."""
         if self.ds:
             # Read in samples from dataset

pyratk/radars/radar.py

@@ -199,7 +199,9 @@ class Receiver(object):
         # print('dc.shape',dc.shape)
         self.fft_mat = self.compute_fft2(self.datacube[-1], (self.slow_fft_size, self.fast_fft_size))
         # self.fft_mat=np.multiply(self.fft_mat,self.mti_window)
-        self.fft_mat[int(self.slow_center_bin), :] = np.zeros(self.fft_mat.shape[1]).T
+
+        self.fft_mat[int(self.slow_center_bin), :] = 0
+
         # print('fft_mat.shape', self.fft_mat.shape)
 
         # if self.datacube[-1].shape == self.datacube[-2].shape:

pyratk/trackers/aps_tracker.py

@@ -17,7 +17,7 @@ class ApsTracker(object):
     """Class to track detections using 4 doppler measurements."""
 
     # === INITIALIZATION METHODS ============================================= #
-    def __init__(self, daq, receiver_array):
+    def __init__(self, daq, receiver_array, moving_average_weight=1.0):
         """
         Initialize tracker class.
         """
@@ -26,6 +26,11 @@ class ApsTracker(object):
         self.receiver_array = receiver_array
         self.detections = []
 
+        self.max_freq = np.zeros(len(receiver_array))
+        self.max_range = np.zeros(len(receiver_array))
+
+        self.weight = moving_average_weight
+
         self.pulse = self.receiver_array[0].transmitter.pulses[0]
         self.chirp_rate = self.pulse.bw / self.pulse.delay
 
@@ -50,19 +55,23 @@ class ApsTracker(object):
         """
 
         self.detections.clear()
+        self.max_range *= 1.0 - self.weight
 
         # Add new Detection objects to detections list
 
         fft_mats = [self.receiver_array[0].fft_mat, self.receiver_array[1].fft_mat]
-        var0=np.power(np.mean(self.receiver_array[0].fft_mat,axis=0),2)
-        var1=np.power(np.mean(self.receiver_array[1].fft_mat,axis=0),2)
+        var0 = np.power(np.mean(self.receiver_array[0].fft_mat,axis=0),2)
+        var1 = np.power(np.mean(self.receiver_array[1].fft_mat,axis=0),2)
         #var0=signal.resample_poly(var00,4,1)
         #var1=signal.resample_poly(var01,4,1)
-        f=np.linspace(-50000,50000,num=var0.size)
-        r_d0=np.abs(f[np.argmax(var0)]*3e8/self.chirp_rate/2)
-        r_d1=np.abs(f[np.argmax(var1)]*3e8/self.chirp_rate/2)
-        theta=np.arcsin((r_d0-r_d1)/self.baseline)+0.5*np.pi
-        R=0.5*(r_d0+r_d1)
+        self.max_freq[0] = (np.argmax(var0, axis=0) - self.receiver_array[0].fast_center_bin) * self.receiver_array[0].fast_bin_size
+        self.max_freq[1] = (np.argmax(var1, axis=0) - self.receiver_array[1].fast_center_bin) * self.receiver_array[1].fast_bin_size
+
+        self.max_range[0] += (np.abs(self.max_freq[0] * 3e8/self.chirp_rate/2) - 2.47) * self.weight
+        self.max_range[1] += (np.abs(self.max_freq[1] * 3e8/self.chirp_rate/2) - 2.47) * self.weight
+
+        theta = np.arcsin((self.max_range[0] - self.max_range[1]) / self.baseline) + np.pi * 0.5
+        R = np.average(self.max_range)
 
         # loc is cylindrical (R, theta, Z), but Z is ignored by plot
         #R = np.random.rand() * 15

pyratk/widgets/polar_tracker_widget.py

@@ -12,11 +12,12 @@ import pyqtgraph as pg
 from pyqtgraph.Qt import QtGui, QtCore
 import numpy as np              # Used for numerical operations
 import platform                 # Get OS for DPI scaling
+import math
 from pyratk.datatypes.geometry import Point, Circle
 
 
 class PolarTrackerWidget(pg.GraphicsLayoutWidget):
-    def __init__(self, tracker, max_range=20):
+    def __init__(self, tracker, max_range=20, moving_average_weight=0.2, trail_length=100):
         super().__init__()
         """
         Initialize polar tracker widget.
@@ -28,11 +29,24 @@ class PolarTrackerWidget(pg.GraphicsLayoutWidget):
                         - power (float): power of detection
                         - doppler (float): Doppler velocity of detection
                         - velocity (Point): Velocity vector (if tracked)
+        max_range - float
+            Maximum range shown on the plot
+
+        moving_average_weight - float
+            Value between 0 and 1 specifying how much weight new values have
+            avg = old * (1 - weight) + new * weight
         """
 
         # Copy arguments to member variables
         self.tracker = tracker
         self.max_range = max_range
+        self.weight = moving_average_weight
+
+        self.det_loc = Point()
+
+        self.trail_length = trail_length
+
+        self.trajectory = []
 
         # Add plots to layout
         self.plot = self.addPlot()
@@ -60,8 +74,11 @@ class PolarTrackerWidget(pg.GraphicsLayoutWidget):
         self.det_loc_plot = pg.ScatterPlotItem(
             size=10, pen=pg.mkPen(None), brush=pg.mkBrush(255, 255, 0, 255))
 
+
         self.plot.addItem(self.det_loc_plot)
 
+        self.pw_trajectory = self.plot.plot()
+
         # Set up plot
         #self.plot.setLimits(yMin=0)
         self.plot.setRange(yRange=[0, self.max_range], xRange=[-self.max_range, self.max_range])
@@ -80,17 +97,33 @@ class PolarTrackerWidget(pg.GraphicsLayoutWidget):
         Draw detections on graph.
         '''
         self.det_loc_plot.clear()
-        for det in self.tracker.detections:
+        if self.tracker.detections:
+            det = self.tracker.detections[0]
+
             R = det.location.p[0]
             theta = det.location.p[1]
 
             x = R * np.cos(theta)
             y = R * np.sin(theta)
 
-            self.det_loc_plot.addPoints(pos=[Point(x, y)])
+            if not math.isnan(theta):
+
+                self.det_loc *= 1.0 - self.weight
+                self.det_loc += Point(x, y) * self.weight
+
+                print('PolarTrackerWidget(): det_loc', self.det_loc)
+
+                self.trajectory.append(self.det_loc)
+
+            data = np.array([(p[0], p[1]) for p in self.trajectory[self.trail_length]])
+            trajectory_pen = pg.mkPen({'color': "FF0A", 'width': 2})
+            self.pw_trajectory.setData(data, pen=trajectory_pen)
+
+            self.det_loc_plot.addPoints(pos=[self.det_loc])
 
     def reset(self):
         # self.tracker.reset()
+        self.trajectory = []
         self.update()
 
     # === UTILITY FUNCTIONS ===================================================

pyratk/widgets/range_doppler_widget.py

@@ -57,8 +57,8 @@ class RangeDopplerWidget(pg.PlotWidget):
 
         # set colormap
         self.img.setLookupTable(lut)
-        self.img.setLevels([-90, -10]) # Good for drone
-        #self.img.setLevels([-10, 20]) # Good for drone
+        self.img.setLevels([-70, -10]) # Good for drone
+        # self.img.setLevels([-60, 10]) # Good for pedestrian
 
         self.rescale()