示例#1
0
    def ICA(self, forehead, nose):

        # Applying ICA
        nose_ica = jade.main(forehead)
        fore_ica = jade.main(nose)

        # Transpose of ICA result
        nose_ica = nose_ica.T
        fore_ica = fore_ica.T
        self.nose_ica_g = nose_ica[1, :]
        self.fore_ica_g = fore_ica[1, :]

        nose_green = nose_ica[1, :]
        nose_green = numpy.ravel(nose_green)
        nose_green = numpy.hamming(self.n_frame) * nose_green

        #fore_green = fore_ica[1,:]
        #fore_green = numpy.ravel(fore_green)
        #fore_green = numpy.hamming(self.n_frame) * fore_green

        #Bandpass filter on the green channel on nose and forehead
        nose_green = self.bandpass_filter(nose_green, 0.95, 2.0, self.fs)
        fore_ica[1, :] = self.bandpass_filter(fore_ica[1, :], 0.75, 2.0,
                                              self.fs)

        #Fourier transform
        r_nosefft = numpy.absolute(numpy.fft.fft(nose_ica[0, :], norm="ortho"))
        g_nosefft = numpy.absolute(numpy.fft.fft(nose_green, norm="ortho"))
        b_nosefft = numpy.absolute(numpy.fft.fft(nose_ica[2, :], norm="ortho"))
        r_forefft = numpy.absolute(numpy.fft.fft(fore_ica[0, :], norm="ortho"))
        g_forefft = numpy.absolute(numpy.fft.fft(fore_ica[1, :], norm="ortho"))
        b_forefft = numpy.absolute(numpy.fft.fft(fore_ica[2, :], norm="ortho"))
        g_nosefft = numpy.ravel(g_nosefft)
        g_forefft = numpy.ravel(g_forefft)

        #Only takes de half of the data
        y_plot_nose = g_nosefft[:self.n_frame // 2]
        y_plot_fore = g_forefft[:self.n_frame // 2]

        self.index_nose = numpy.argmax(y_plot_nose)
        self.index_fore = numpy.argmax(y_plot_fore)

        self.bpm_a = self.xf[self.index_nose] * 60
        self.bpm_b = self.xf[self.index_fore] * 60

        #Gets the pulse
        self.window_hr = self.get_pulse(self.bpm_a)

        print(self.bpm_a, "BPM NARIZ")
        print(self.bpm_b, "BPM FORE")
示例#2
0
    def ICA(self):

        # Applying ICA
        nose_ica = jade.main(self.ica_both)
        nose_ica_b = self.ica_both_b
        nose_ica = nose_ica.T

        nose_green = nose_ica[0, :]
        nose_green = np.ravel(nose_green)
        nose_green = np.hamming(len(nose_green)) * nose_green
        nose_green_b = nose_ica_b[0, :]
        nose_green_b = np.ravel(nose_green_b)
        nose_green_b = np.hamming(len(nose_green_b)) * nose_green_b
        #Bandpass filter on the green channel on nose and forehead
        nose_green = self.bandpass_filter(nose_green, 0.90, 1.7,
                                          self.fs)  #ESTA E N 0.95 a 2.0
        fore_ica = self.bandpass_filter(nose_ica[1, :], 0.90, 1.7, self.fs)
        nose_green_b = self.bandpass_filter(nose_green_b, 0.90, 1.7, self.fs)
        fore_green_b = self.bandpass_filter(nose_ica_b[1, :], 0.90, 1.7,
                                            self.fs)

        #Fourier transform
        g_nosefft = np.absolute(np.fft.fft(nose_green, norm="ortho"))
        f_forefft = np.absolute(np.fft.fft(fore_ica, norm="ortho"))
        g_nosefft_b = np.absolute(np.fft.fft(nose_green_b, norm="ortho"))
        g_forefft_b = np.absolute(np.fft.fft(fore_green_b, norm="ortho"))
        g_nosefft = np.ravel(g_nosefft)
        g_forefft = np.ravel(f_forefft)
        g_nosefft_b = np.ravel(g_nosefft_b)
        g_forefft_b = np.ravel(g_forefft_b)

        #Only takes de half of the data
        y_plot_nose = g_nosefft[:self.n_frame // 2]
        y_plot_fore = g_forefft[:self.n_frame // 2]
        y_plot_nose_b = g_nosefft_b[:self.n_frame // 2]
        y_plot_fore_b = g_forefft_b[:self.n_frame // 2]
        self.index_nose = np.argmax(y_plot_nose)
        self.index_fore = np.argmax(y_plot_fore)
        self.index_nose_b = np.argmax(y_plot_nose_b)
        self.index_fore_b = np.argmax(y_plot_fore_b)

        #Calculates the hearth rate
        self.bpm_a = self.xf[self.index_nose] * 60
        self.bpm_b = self.xf[self.index_fore] * 60
        self.bpm_a_b = self.xf[self.index_nose_b] * 60
        self.bpm_b_b = self.xf[self.index_fore_b] * 60

        # cwtmatr , freqs = pywt.cwt(y_plot_nose, len(y_plot_nose)  , "morl", self.fs)
        #Gets the pulse
        self.window_hr = self.get_pulse(self.bpm_a)
        self.window_hr_b = self.get_pulse_b(self.bpm_a_b)
        print(self.bpm_a, "BPM componente 1")
        print(self.bpm_b, "BPM componente 2")
        print(self.bpm_a_b, "BPM componente 1 metodo 2")
        print(self.bpm_b_b, "BPM componente 2 metodo 2")
示例#3
0
def parse_RGB(message):
    buffer_window = message["bufferWindow"]

    # # ** FOR GREEN CHANNEL ONLY **
    # X = np.array(message["array"])
    # X = normalize_array(X)
    # return json.dumps(parse_ICA_results(X, buffer_window))

    # ** FOR RGB CHANNELS & ICA **
    X = np.ndarray(shape=(3, buffer_window), buffer=np.array(message["array"]))
    X = normalize_matrix(X)
    ICA = jade.main(X)
    return json.dumps(parse_ICA_results(ICA, buffer_window))  #message["time"]
示例#4
0
文件: model.py 项目: DengQ/pulse
def parse_RGB(message):
	buffer_window = message["bufferWindow"]

	# # ** FOR GREEN CHANNEL ONLY **
	# X = np.array(message["array"])
	# X = normalize_array(X)
	# return json.dumps(parse_ICA_results(X, buffer_window))

	# ** FOR RGB CHANNELS & ICA **
	X = np.ndarray(shape = (3, buffer_window), buffer= np.array(message["array"]))
	X = normalize_matrix(X)
	ICA = jade.main(X)
	return json.dumps(parse_ICA_results(ICA, buffer_window)) #message["time"]
示例#5
0
    def ICA(self):

        # Applying ICA
        nose_ica = jade.main(self.ica_both)

        # Transpose of ICA result
        nose_ica = nose_ica.T

        #nose_green = nose_ica[1,:]
        nose_green = nose_ica[0, :]
        nose_green = np.ravel(nose_green)
        nose_green = np.hamming(self.n_frame) * nose_green

        #Bandpass filter on the green channel on nose and forehead
        nose_green = self.bandpass_filter(nose_green, 0.95, 2.0, self.fs)
        fore_ica = self.bandpass_filter(nose_ica[1, :], 0.95, 2.0, self.fs)

        #Fourier transform
        g_nosefft = np.absolute(np.fft.fft(nose_green, norm="ortho"))
        f_forefft = np.absolute(np.fft.fft(fore_ica, norm="ortho"))
        g_nosefft = np.ravel(g_nosefft)
        g_forefft = np.ravel(f_forefft)

        #Only takes de half of the data
        y_plot_nose = g_nosefft[:self.n_frame // 2]
        y_plot_fore = g_forefft[:self.n_frame // 2]

        self.index_nose = np.argmax(y_plot_nose)
        self.index_fore = np.argmax(y_plot_fore)

        self.bpm_a = self.xf[self.index_nose] * 60
        self.bpm_b = self.xf[self.index_fore] * 60

        #Gets the pulse
        self.window_hr = self.get_pulse(self.bpm_a)
        print(self.bpm_a, "BPM componente 1")
        print(self.bpm_b, "BPM componente 2")
示例#6
0
def parse_RGB(buffer_window, sample):
    X = np.ndarray(shape=(3, buffer_window), buffer=np.array(sample))
    X = normalize_matrix(X)
    ICA = jade.main(X)
    signalFFT = parse_ICA_results(ICA)
    return signalFFT
示例#7
0
def main():
    """SETTINGS

  1. Common settings:

    Common settings include the values or methods shared with all algorithm to solve task assignment problem(TAP),
    and these values and methods should be the same for evaluatate fairly.

    First, the basic scale of TAP should be set:
    ############################################
    r: 
      Number of the tasks.
      In this project, it recommanded set with following values: 5, 10, 15, 20, 30, 50.

    n:
      Number of the processors.
      In this project, it recommanded set with following values: 3, 6, 9, 12, 18 ,30.
    ############################################

    Then, some specific parameters for TAP:
    ############################################
    execution_cost:
      The matrix which represent the exact cost value for task i would cost how much on processor j.
      exec_cost_min:
        The minimal cost for the cost value.
      exec_cost_max:
        The maximal cost for the cost value.

    communication_cost:
      It would be represent as a matrix, but it's a little hard to explain which it is,
      so plz read the related ref or this code if you could=]
      comm_density:
        The density of the value in the matrix.
        It recommanded set with following values: 0.3, 0.5, 0.8.
      comm_cost_min:
        The minimal value of communication.
      comm_cost_max:
        The maximal value of communication.

    processing_cost:
      A matrix to represent the prossing cost for each task on specific processor.
      processing_cost_min:
        The minimal value of processing cost.
      processing_cost_max:
        The maximal value of processing cost.

    processing_limitation:
      The processing limitation for each processor.
      proc_cost_min:
        The minimal limitation of processing.
      proc_cost_max:
        The maximal limitation of processing.

    mem_cost:
      A matrix to represent the memory cost for each task on specific processor.
      mem_cost_min:
        The minimal value of memory cost.
      mem_cost_max:
        The maximal value of memory cost.

    mem_limitation:
      The memory limitation for each processor.
      mem_cost_min:
        The minimal limitation of memory.
      mem_cost_max:
        The maximal limitation of memory.
    ############################################


    Last, some parameter for DE algorithm:
    ############################################
    M:
      Number of individual in each iteration
      In this project, it recommanded set with following numbers: 15, 20, 25, 30, 35, 40

    K:
      Iteration times
      In this project, it recommanded set with following numbers: 50, 100, 150, 200, 250, 300
    ############################################


  2. Specific setting:
    2.1 ODE Algorithm
      The ODE algorithm add an extra judge to expand the search.
      F:
        the F constant
      CR: 
        the CR constant
      JR:
        the jump rate

    2.2 JADE Algorithm

    2.3. IDE Algorithm
      The IDE algorithm has dynamic CR value and F value while the F is depends on the values in each iteration.
      So only CR value should be set with some constant.
      cr_min: 
        the lower limitation of the CR value.
      cr_max:
        the higher limitation of the CR value.
      l:
        the lambda value
  """
    # Start of settings
    # Common settings
    r = 10
    n = 6
    M = 50
    K = 80
    exec_cost_min = 0
    exec_cost_max = 200
    execution_cost = utils.generate_common_cost(n, r, exec_cost_min,
                                                exec_cost_max)
    comm_density = 0.8
    comm_cost_min = 0
    comm_cost_max = 50
    communication_cost = utils.generate_communication_cost(
        r, comm_density, comm_cost_min, comm_cost_max)
    proc_cost_min = 1
    proc_cost_max = 50
    processing_cost = utils.generate_common_cost(n, r, proc_cost_min,
                                                 proc_cost_max)
    proc_limitation_min = 50
    proc_limitation_max = 250
    processing_limitation = utils.generate_common_limitation(
        n, proc_limitation_min, proc_limitation_max)
    mem_cost_min = 1
    mem_cost_max = 50
    memory_cost = utils.generate_common_cost(n, r, mem_cost_min, mem_cost_max)
    mem_limitation_min = 50
    mem_limitation_max = 250
    memory_limitation = utils.generate_common_limitation(
        n, mem_cost_min, mem_cost_max)

    # Settings for ODE Algorithm
    F = 1
    CR = 0.8
    JR = 0.5

    # Settings for IDE Algorithm
    cr_min = 0.1
    cr_max = 0.9
    l = 10**10
    # End of settings

    # ODE Algorithm
    ode_result = ode.main(r, n, M, K, F, CR, JR, execution_cost,
                          communication_cost, processing_cost,
                          processing_limitation, memory_cost,
                          memory_limitation)

    # JADE Algorithm
    jade_result = jade.main(r, n, M, K, F, CR, execution_cost,
                            communication_cost, processing_cost,
                            processing_limitation, memory_cost,
                            memory_limitation)

    # IDE Algorithm
    ide_result = ide.main(r, n, M, K, cr_min, cr_max, l, execution_cost,
                          communication_cost, processing_cost,
                          processing_limitation, memory_cost,
                          memory_limitation)

    xAxis = numpy.linspace(0, K - 1, num=K)
    plt.plot(xAxis, ode_result, linewidth=2, linestyle="-", label="ODE")
    plt.plot(xAxis, jade_result, linewidth=2, linestyle="-", label="JADE")
    plt.plot(xAxis, ide_result, linewidth=2, linestyle="-", label="IDE")
    plt.legend()
    plt.title(
        "ODE/JADE/IDE Algorithm for task assignment problem\nParameters: number of tasks: "
        + str(r) + ", number of processor: " + str(n))
    plt.xlabel("iteration")
    plt.ylabel("function value")
    plt.grid(True)
    plt.show()