Exemple #1
0
def roberts_filter(arr):
    padded = padding(arr)

    for x in range(arr.shape[0]):
        for y in range(arr.shape[1]):
            padded[x, y, 0] = bound(
                np.absolute(
                    np.sum(np.multiply(padded[x:x + 2, y:y + 2,
                                              0], roberts1))) +
                np.absolute(
                    np.sum(np.multiply(padded[x:x + 2, y:y + 2,
                                              0], roberts2))))
            padded[x, y, 1] = bound(
                np.absolute(
                    np.sum(np.multiply(padded[x:x + 2, y:y + 2,
                                              1], roberts1))) +
                np.absolute(
                    np.sum(np.multiply(padded[x:x + 2, y:y + 2,
                                              1], roberts2))))
            padded[x, y, 2] = bound(
                np.absolute(
                    np.sum(np.multiply(padded[x:x + 2, y:y + 2,
                                              2], roberts1))) +
                np.absolute(
                    np.sum(np.multiply(padded[x:x + 2, y:y + 2,
                                              2], roberts2))))

    return padded
Exemple #2
0
def main(args):
    img = im_to_arr(args[0])

    r_lut = bound(np.array(range(0, 256)) + 50)
    g_lut = bound(np.array(range(0, 256)) + 40)
    b_lut = bound(np.array(range(0, 256)) - 100)
    img[:, :, 0] = lut_mainp(img[:, :, 2], r_lut)
    img[:, :, 1] = lut_mainp(img[:, :, 2], g_lut)
    img[:, :, 2] = lut_mainp(img[:, :, 2], b_lut)

    img = Image.fromarray(img.astype(np.uint8))
    img.show()
Exemple #3
0
def applyFilter(arr, filter):
    padded = padding(arr)
    for x in range(arr.shape[0]):
        for y in range(arr.shape[1]):
            padded[x + 1, y + 1, 0] = bound(
                np.sum(np.multiply(padded[x:x + 3, y:y + 3, 0], filter)))
            padded[x + 1, y + 1, 1] = bound(
                np.sum(np.multiply(padded[x:x + 3, y:y + 3, 1], filter)))
            padded[x + 1, y + 1, 2] = bound(
                np.sum(np.multiply(padded[x:x + 3, y:y + 3, 2], filter)))

    return padded
    def process(self):
        twist_body = addict.Dict()
        twist_body.linear = self.state.to_body(self.state.twist.linear)
        twist_body.angular = self.state.to_body(self.state.twist.angular)
        load_factor = utils.bound(self.state.load_factor, self.load_factor_limit)

        acceleration_command = np.array([0.0, 0.0, 0.0])
        acceleration_command[0] = self.pid.linear.x.update(
            self.input_.twist.linear.x, self.state.twist.linear[0], self.state.acceleration[0], self.dt
        )
        acceleration_command[1] = self.pid.linear.y.update(
            self.input_.twist.linear.y, self.state.twist.linear[1], self.state.acceleration[1], self.dt
        )
        acceleration_command[2] = (
            self.pid.linear.z.update(
                self.input_.twist.linear.z, self.state.twist.linear[2], self.state.acceleration[2], self.dt
            )
            + self.state.gravity
        )
        acceleration_command_body = self.state.to_body(acceleration_command)

        if self.verbose:
            utils.pv(
                "twist_body",
                "self.state.load_factor",
                "load_factor",
                "acceleration_command",
                "acceleration_command_body",
            )

        self.output.wrench.torque.x = self.state.inertia[0] * self.pid.angular.x.update(
            -acceleration_command_body[1] / self.state.gravity, 0.0, twist_body.angular[0], self.dt
        )
        self.output.wrench.torque.y = self.state.inertia[1] * self.pid.angular.y.update(
            acceleration_command_body[0] / self.state.gravity, 0.0, twist_body.angular[1], self.dt
        )
        self.output.wrench.torque.z = self.state.inertia[2] * self.pid.angular.z.update(
            self.input_.twist.angular.z, self.state.twist.angular[2], 0.0, self.dt
        )

        self.output.wrench.force.x = 0.0
        self.output.wrench.force.y = 0.0
        self.output.wrench.force.z = self.state.mass * (
            (acceleration_command[2] - self.state.gravity) * load_factor + self.state.gravity
        )

        self.output.wrench.force.z = utils.bound(self.output.wrench.force.z, self.force_z_limit)
        self.output.wrench.force.z = max(self.output.wrench.force.z, 0.0)
        self.output.wrench.torque.x = utils.bound(self.output.wrench.torque.x, self.torque_xy_limit)
        self.output.wrench.torque.y = utils.bound(self.output.wrench.torque.y, self.torque_xy_limit)
        self.output.wrench.torque.z = utils.bound(self.output.wrench.torque.z, self.torque_z_limit)
Exemple #5
0
    def process(self):
        twist_body = addict.Dict()
        twist_body.linear = self.state.to_body(self.state.twist.linear)
        twist_body.angular = self.state.to_body(self.state.twist.angular)
        load_factor = utils.bound(self.state.load_factor,
                                  self.load_factor_limit)

        acceleration_command = np.array([0.0, 0.0, 0.0])
        acceleration_command[0] = self.pid.linear.x.update(
            self.input_.twist.linear.x, self.state.twist.linear[0],
            self.state.acceleration[0], self.dt)
        acceleration_command[1] = self.pid.linear.y.update(
            self.input_.twist.linear.y, self.state.twist.linear[1],
            self.state.acceleration[1], self.dt)
        acceleration_command[2] = self.pid.linear.z.update(
            self.input_.twist.linear.z, self.state.twist.linear[2],
            self.state.acceleration[2], self.dt) + self.state.gravity
        acceleration_command_body = self.state.to_body(acceleration_command)

        if self.verbose:
            utils.pv('twist_body', 'self.state.load_factor', 'load_factor',
                     'acceleration_command', 'acceleration_command_body')

        self.output.wrench.torque.x = self.state.inertia[
            0] * self.pid.angular.x.update(
                -acceleration_command_body[1] / self.state.gravity, 0.0,
                twist_body.angular[0], self.dt)
        self.output.wrench.torque.y = self.state.inertia[
            1] * self.pid.angular.y.update(
                acceleration_command_body[0] / self.state.gravity, 0.0,
                twist_body.angular[1], self.dt)
        self.output.wrench.torque.z = self.state.inertia[
            2] * self.pid.angular.z.update(self.input_.twist.angular.z,
                                           self.state.twist.angular[2], 0.0,
                                           self.dt)

        self.output.wrench.force.x = 0.0
        self.output.wrench.force.y = 0.0
        self.output.wrench.force.z = self.state.mass * \
            ((acceleration_command[2] - self.state.gravity) * load_factor + self.state.gravity)

        self.output.wrench.force.z = utils.bound(self.output.wrench.force.z,
                                                 self.force_z_limit)
        self.output.wrench.force.z = max(self.output.wrench.force.z, 0.0)
        self.output.wrench.torque.x = utils.bound(self.output.wrench.torque.x,
                                                  self.torque_xy_limit)
        self.output.wrench.torque.y = utils.bound(self.output.wrench.torque.y,
                                                  self.torque_xy_limit)
        self.output.wrench.torque.z = utils.bound(self.output.wrench.torque.z,
                                                  self.torque_z_limit)
Exemple #6
0
    def pid(self, error, dx, dt):
        if self.verbose:
            print "error: {}, dx: {}, dt: {}".format(error, dx, dt)

        if math.isnan(error):
            return 0.0

        # integral error
        self.state.i += error * dt
        self.state.i = utils.bound(self.state.i, self.params.limit_i)

        # differential error
        if dt > 0.0 and not math.isnan(self.state.p) and not math.isnan(
                self.state.dx):
            self.state.d = (error - self.state.p) / dt + self.state.dx - dx
        else:
            self.state.d = -dx
        self.state.dx = dx

        # proportional error
        self.state.p = error

        # calculate output...
        output = self.params.k_p * self.state.p +\
            self.params.k_i * self.state.i + \
            self.params.k_d * self.state.d

        if self.verbose:
            print "output: {}, k_p: {}, p: {}, k_i: {}, i: {}, k_d: {}, d: {}".format(
                output, self.params.k_p, self.state.p, self.params.k_i,
                self.state.i, self.params.k_d, self.state.d)

        antiwindup = 0
        if self.params.limit_output > 0.0:
            if output > self.params.limit_output:
                antiwindup = 1
            elif output < -self.params.limit_output:
                antiwindup = -1

        output = utils.bound(output, self.params.limit_output)

        if antiwindup != 0 and error * dt * antiwindup > 0.0:
            self.state.i -= error * dt

        if math.isnan(output):
            output = 0.0

        return output
    def start_deviation(self, a_step: int):
        self.settings[self.MEASURE_SECTION][self.START_DEVIATION_KEY] = str(
            a_step)
        self.save()

        self.__start_deviation = a_step
        self.__start_deviation = utils.bound(self.__start_deviation, 0, 100)
    def mouse_inversion(self, a_enable: int):
        self.settings[self.MEASURE_SECTION][self.MOUSE_INVERSION_KEY] = str(
            a_enable)
        self.save()

        self.__mouse_inversion = a_enable
        self.__mouse_inversion = utils.bound(self.__mouse_inversion, 0, 1)
Exemple #9
0
 def frequency_changed(self):
     actual_frequency = utils.bound(self.__clb_dll.get_frequency(), clb.MIN_FREQUENCY, clb.MAX_FREQUENCY)
     if self.__frequency != actual_frequency:
         self.__frequency = actual_frequency
         return True
     else:
         return False
Exemple #10
0
def main(args):
    m = 100
    img = im_to_arr(args[0])
    m = max(0, min(m, 255))
    inv = bound(img + m)
    inv = Image.fromarray(inv.astype(np.uint8))
    inv.show()
Exemple #11
0
    def pid(self, error, dx, dt):
        if self.verbose:
            print "error: {}, dx: {}, dt: {}".format(error, dx, dt)

        if math.isnan(error):
            return 0.0

        # integral error
        self.state.i += error * dt
        self.state.i = utils.bound(self.state.i, self.params.limit_i)

        # differential error
        if dt > 0.0 and not math.isnan(self.state.p) and not math.isnan(self.state.dx):
            self.state.d = (error - self.state.p) / dt + self.state.dx - dx
        else:
            self.state.d = -dx
        self.state.dx = dx

        # proportional error
        self.state.p = error

        # calculate output...
        output = self.params.k_p * self.state.p +\
            self.params.k_i * self.state.i + \
            self.params.k_d * self.state.d

        if self.verbose:
            print "output: {}, k_p: {}, p: {}, k_i: {}, i: {}, k_d: {}, d: {}".format(
                output, self.params.k_p, self.state.p, self.params.k_i,
                self.state.i, self.params.k_d, self.state.d)

        antiwindup = 0
        if self.params.limit_output > 0.0:
            if output > self.params.limit_output:
                antiwindup = 1
            elif output < -self.params.limit_output:
                antiwindup = -1

        output = utils.bound(output, self.params.limit_output)

        if antiwindup != 0 and error * dt * antiwindup > 0.0:
            self.state.i -= error * dt

        if math.isnan(output):
            output = 0.0

        return output
    def disable_scroll_on_table(self, a_enable: int):
        self.settings[self.MEASURE_SECTION][
            self.DISABLE_SCROLL_ON_TABLE_KEY] = str(a_enable)
        self.save()

        self.__disable_scroll_on_table = a_enable
        self.__disable_scroll_on_table = utils.bound(
            self.__disable_scroll_on_table, 0, 1)
    def fixed_step_idx(self, a_idx: int):
        self.settings[self.MEASURE_SECTION][self.FIXED_STEP_IDX_KEY] = str(
            a_idx)
        self.save()

        self.__fixed_step_idx = a_idx
        self.__fixed_step_idx = utils.bound(self.__fixed_step_idx, 0,
                                            len(self.__fixed_step_list) - 1)
Exemple #14
0
 def limit_amplitude(self, a_amplitude, a_lower, a_upper):
     """
     Обрезает значение амплитуды с учетом типа сигнала и параметров пользователя
     :param a_amplitude: Заданная амплитуда
     :param a_lower: Нижняя граница
     :param a_upper: Верхняя граница
     """
     return utils.bound(clb.bound_amplitude(a_amplitude, self.__signal_type), a_lower, a_upper)
    def set_amplitude(self, a_amplitude: float):
        self.calibrator.amplitude = utils.bound(a_amplitude,
                                                self.lowest_amplitude,
                                                self.highest_amplitude)
        self.ui.amplitude_edit.setText(
            self.value_to_user(self.calibrator.amplitude))

        self.amplitude_edit_text_changed()
        self.update_current_point(self.calibrator.amplitude)
Exemple #16
0
def bound_amplitude(a_amplitude: float, a_signal_type: SignalType):
    min_value = MIN_VOLTAGE
    max_value = MAX_VOLTAGE
    if not is_voltage_signal[a_signal_type]:
        min_value = MIN_CURRENT
        max_value = MAX_CURRENT
    if is_ac_signal[a_signal_type]:
        min_value = MIN_ALTERNATIVE
    return round(bound(a_amplitude, min_value, max_value), 9)
Exemple #17
0
def main(args):
    try:
        img = Image.open(args[0])
    except FileNotFoundError:
        print('usege: python color_inversion.py <name of a file to convert>')
    else:
        img = np.array(img.convert('RGB'))

        inv = bound(255 - img)
        inv = Image.fromarray(inv).convert("RGB")
        inv.show()
Exemple #18
0
    def get_action(self, i, obs):
        if i <= self.pause_time:
            input_to_net = np.array(obs[0] + obs[1] + obs[2] + obs[3] +
                                    list(obs[4]) + [i / self.pause_time])
            with torch.no_grad():
                input_to_net = torch.Tensor(input_to_net)
                action = self.action_network(input_to_net).numpy()

                # hypothesis: control in speed instead of position
                action = self.last_action[:7] + self.gain * action

                utils.bound(action, self.action_bounds)

            if i < self.grip_time:
                action = np.append(action, 1)  # gripper is open
            else:
                action = np.append(action, -1)  # gripper is closed
            self.last_action = action
        else:
            # feed last action
            action = self.last_action
        return action
Exemple #19
0
def voltage_to_dac_code(a_voltage: float, r1: float, r2: float, r3: float,
                        v0: float):
    v_max = 3.3
    u1 = v0 + r1 * (v0 / r2 - (a_voltage - v0) / r3)
    float_code = 1 - u1 / v_max
    float_code = utils.bound(float_code, 0, 1)

    float_code_discrete = floor(float_code * 255) / 255
    voltage_discrete = (v0 / r2 -
                        (v_max *
                         (1 - float_code_discrete) - v0) / r1) * r3 + v0

    return float_code, voltage_discrete
Exemple #20
0
    def status(self):
        response = bound(
            self._response,
            self.min_time,
            self.max_time)

        diff = (response - self.min_time) / self._step
        pixel = bytearray(3)
        pixel[0] = byte_bound(diff)
        pixel[1] = byte_bound(254 - diff)
        pixel[2] = 0

        return (colors.STATIC, pixel)
    def write_variable(self, a_variable_number: int, a_variable_value: float):
        variable_info = self.__variables_info[a_variable_number]
        if variable_info.c_type == 'o':
            value = int(utils.bound(a_variable_value, 0, 1))
            self.__calibrator.write_bit(variable_info.index,
                                        variable_info.bit_index, value)
        else:
            if variable_info.c_type != 'd' and variable_info.c_type != 'f':
                a_variable_value = int(a_variable_value)

            _bytes = struct.pack(variable_info.c_type, a_variable_value)
            self.__calibrator.write_raw_bytes(variable_info.index,
                                              variable_info.size, _bytes)
	def gen_sample_pair(self, files_list, mode='train'):

		image_size = self.hmap[random.choice(files_list)].shape[0]

		while True:
			coord_range = (window_size*1.25//2 + 1, image_size - window_size*1.25//2 - 1)

			normal_queue = self.sample_with_error(target=0, image_files=files_list, coord_range=coord_range, 
				initial_sample_num=self.normal_sampling[0], 
				final_sample_num=int(self.normal_sampling[0]*self.normal_sampling[1]))

			mitosis_queue = self.sample_with_error(target=1, image_files=files_list, coord_range=coord_range, 
				initial_sample_num=self.mitosis_sampling[0], 
				final_sample_num=int(self.mitosis_sampling[0]*self.mitosis_sampling[1]))

			queue = np.append(normal_queue, mitosis_queue, axis=0)
			target = np.append(np.zeros(len(normal_queue)), np.ones(len(mitosis_queue)))
			queue, target = shuffle(queue, target)

			for (image_file, x, y), target_val in zip(queue, target):

				#x, y = x + random.randint(-8, 8), y + random.randint(-8, 8)
				x, y = int(x), int(y)

				window_size_exp = window_size
				if random.randint(0, 1) == 0:
					window_size_exp = int(window_size * random.choice([0.75, 0.8, 1.0, 1.2, 1.25]))

				xs, ys = x - window_size_exp//2, y - window_size_exp//2
				xs, ys = bound((xs, ys), low=1, high=image_size - window_size_exp -1)

				pred = np.array([[[1 - target_val, target_val]]])
				img = self.img[image_file][xs:(xs + window_size_exp), ys:(ys + window_size_exp)]
				img = scipy.misc.imresize(img, (window_size, window_size, 3))/255.0

				if random.randint(0, 1) == 0:
					img = np.rot90(img)

				if random.randint(0, 1) == 0:
					img = np.fliplr(img)

				if random.randint(0, 1) == 0:
					img = np.flipud(img)

				if random.randint(0, 3) == 0:
					angle = random.randint(-25, 25)
					img = rotate(img, angle, reshape=False)

				yield img, pred
    def fixed_step_list(self, a_list: List[float]):
        # Удаляет дубликаты
        final_list = list(dict.fromkeys(a_list))
        final_list.sort()

        saved_string = ','.join(str(val) for val in final_list)
        saved_string = saved_string.strip(',')

        self.settings[self.MEASURE_SECTION][self.FIXED_STEP_KEY] = saved_string
        self.save()

        self.__fixed_step_list = [val for val in final_list]
        self.__fixed_step_idx = utils.bound(self.__fixed_step_idx, 0,
                                            len(self.__fixed_step_list) - 1)
        self.fixed_step_changed.emit()
    def go_to_point(self):
        rows = self.measure_manager.view().get_selected_rows()
        if rows:
            row_idx = rows[0].row()
            target_amplitude = utils.parse_input(
                self.measure_manager.view().get_point_by_row(row_idx))
            target_frequency = float(
                self.measure_manager.view().get_frequency_by_row(
                    row_idx).replace(',', '.'))

            if target_amplitude != self.calibrator.amplitude:
                measured_up = self.measure_manager.view(
                ).is_point_measured_by_row(row_idx, PointData.ApproachSide.UP)
                measured_down = self.measure_manager.view(
                ).is_point_measured_by_row(row_idx,
                                           PointData.ApproachSide.DOWN)

                if measured_down == measured_up:
                    # Точка измерена полностью либо совсем не измерена, подходим с ближайшей стороны
                    if self.calibrator.amplitude > target_amplitude:
                        change_value_foo = utils.increase_by_percent
                    else:
                        change_value_foo = utils.decrease_by_percent
                else:
                    if measured_up:
                        change_value_foo = utils.decrease_by_percent
                    else:
                        change_value_foo = utils.increase_by_percent

                target_amplitude = change_value_foo(
                    target_amplitude,
                    self.settings.start_deviation,
                    a_normalize_value=self.current_case.limit)

                target_amplitude = utils.bound(target_amplitude,
                                               self.lowest_amplitude,
                                               self.highest_amplitude)
                target_frequency = clb.bound_frequency(
                    target_frequency, self.current_case.signal_type)
                self.start_approach_to_point(target_amplitude,
                                             target_frequency)
	def gen_sample_pair(self, files_list, mode='train'):
		while True:

			image_file = random.choice(files_list)
			hmap = self.hmap[image_file]
			if hmap.sum()*1.0/(window_size*window_size) <= 0.1: continue
			target = np.random.choice([0, 1], p=[0.5, 0.5])

			window_size_exp = window_size
			if random.randint(0, 1) == 0:
				window_size_exp = int(window_size * random.choice([0.75, 0.8, 1.0, 1.2, 1.25]))
			
			while True:
				x = random.randint(window_size_exp//2 + 10, hmap.shape[0] - window_size_exp//2 - 10)
				y = random.randint(window_size_exp//2 + 10, hmap.shape[0] - window_size_exp//2 - 10)
				if target == hmap[x, y]:
					break

			#x, y = x + random.randint(-8, 8), y + random.randint(-8, 8)
			xs, ys = x - window_size_exp//2, y - window_size_exp//2
			xs, ys = bound((xs, ys), low=1, high=hmap.shape[0] - window_size -1)

			pred = np.array([[[1 - target, target]]])
			img = self.img[image_file][xs:(xs + window_size_exp), ys:(ys + window_size_exp)]
			img = scipy.misc.imresize(img, (window_size, window_size, 3))/255.0

			if random.randint(0, 1) == 0:
				img = np.rot90(img)

			if random.randint(0, 1) == 0:
				img = np.fliplr(img)

			if random.randint(0, 1) == 0:
				img = np.flipud(img)

			if random.randint(0, 2) == 0:
				angle = random.randint(-25, 25)
				img = rotate(img, angle, reshape=False)

			yield img, pred
	def gen_sample_pair(self, files_list, mode='train'):
		while True:

			image_file = random.choice(files_list)
			hmap = self.hmap[image_file]
			target = np.random.choice([0, 1], p=[0.5, 0.5])

			window_size_exp = window_size
			if random.randint(0, 1) == 0:
				window_size_exp = int(window_size * random.choice([0.75, 0.8, 1.0, 1.2, 1.25]))
			
			while True:
				x = random.randint(window_size_exp//2 + 10, hmap.shape[0] - window_size_exp//2 - 10)
				y = random.randint(window_size_exp//2 + 10, hmap.shape[1] - window_size_exp//2 - 10)
				if target == int(round(hmap[x, y])):
					break
			#x, y = x + random.randint(-8, 8), y + random.randint(-8, 8)
			xs, ys = x - window_size_exp//2, y - window_size_exp//2
			xs, ys = bound((xs, ys), low=1, high=hmap.shape[0] - window_size -1)

			pred = np.array([[[1 - hmap[x, y], hmap[x, y]]]])
			img = self.img[image_file][xs:(xs + window_size_exp), ys:(ys + window_size_exp)]
			img = scipy.ndimage.zoom(img, zoom=(window_size*1.0/window_size_exp, window_size*1.0/window_size_exp, 1))
			assert img.shape == (window_size, window_size, 20)

			if random.randint(0, 1) == 0:
				img = np.rot90(img)

			if random.randint(0, 1) == 0:
				img = np.fliplr(img)

			if random.randint(0, 1) == 0:
				img = np.flipud(img)

			if random.randint(0, 2) == 0:
				angle = random.randint(-25, 25)
				img = rotate(img, angle, reshape=False, mode='reflect')

			yield img, pred
Exemple #27
0
    def forward(self, c, h_bottom, h, h_top, z, z_bottom):
        # h_bottom.size = bottom_size * batch_size
        s_recur = torch.mm(self.W_01, h_bottom)
        if not self.last_layer:
            s_topdown_ = torch.mm(self.U_21, h_top)
            s_topdown = z.expand_as(s_topdown_) * s_topdown_
        else:
            s_topdown = Variable(torch.zeros(s_recur.size()).cuda(), requires_grad=False).cuda()
        s_bottomup_ = torch.mm(self.U_11, h)
        s_bottomup = z_bottom.expand_as(s_bottomup_) * s_bottomup_

        f_s = s_recur + s_topdown + s_bottomup + self.bias.unsqueeze(1).expand_as(s_recur)
        # f_s.size = (4 * hidden_size + 1) * batch_size
        f = Func.sigmoid(f_s[0:self.hidden_size, :])  # hidden_size * batch_size
        i = Func.sigmoid(f_s[self.hidden_size:self.hidden_size*2, :])
        o = Func.sigmoid(f_s[self.hidden_size*2:self.hidden_size*3, :])
        g = Func.tanh(f_s[self.hidden_size*3:self.hidden_size*4, :])
        z_hat = hard_sigm(self.a, f_s[self.hidden_size*4:self.hidden_size*4+1, :])

        one = Variable(torch.ones(f.size()).cuda(), requires_grad=False)
        z = z.expand_as(f)
        z_bottom = z_bottom.expand_as(f)

        c_new = z * (i * g) + (one - z) * (one - z_bottom) * c + (one - z) * z_bottom * (f * c + i * g)
        h_new = z * o * Func.tanh(c_new) + (one - z) * (one - z_bottom) * h + (one - z) * z_bottom * o * Func.tanh(c_new)

        # if z == 1: (FLUSH)
        #     c_new = i * g
        #     h_new = o * Func.tanh(c_new)
        # elif z_bottom == 0: (COPY)
        #     c_new = c
        #     h_new = h
        # else: (UPDATE)
        #     c_new = f * c + i * g
        #     h_new = o * Func.tanh(c_new)

        z_new = bound()(z_hat)

        return h_new, c_new, z_new
Exemple #28
0
def sobel_filter(arr):
    padded = padding(arr)

    for x in range(arr.shape[0]):
        for y in range(arr.shape[1]):
            r, g, b = 0, 0, 0

            r += np.abs(
                np.sum(np.multiply(padded[x:x + 3, y:y + 3, 0], sobel0)))
            g += np.abs(
                np.sum(np.multiply(padded[x:x + 3, y:y + 3, 1], sobel0)))
            b += np.abs(
                np.sum(np.multiply(padded[x:x + 3, y:y + 3, 2], sobel0)))

            r += np.abs(
                np.sum(np.multiply(padded[x:x + 3, y:y + 3, 0], sobel45)))
            g += np.abs(
                np.sum(np.multiply(padded[x:x + 3, y:y + 3, 1], sobel45)))
            b += np.abs(
                np.sum(np.multiply(padded[x:x + 3, y:y + 3, 2], sobel45)))

            r += np.abs(
                np.sum(np.multiply(padded[x:x + 3, y:y + 3, 0], sobel90)))
            g += np.abs(
                np.sum(np.multiply(padded[x:x + 3, y:y + 3, 1], sobel90)))
            b += np.abs(
                np.sum(np.multiply(padded[x:x + 3, y:y + 3, 2], sobel90)))

            r += np.abs(
                np.sum(np.multiply(padded[x:x + 3, y:y + 3, 0], sobel135)))
            g += np.abs(
                np.sum(np.multiply(padded[x:x + 3, y:y + 3, 1], sobel135)))
            b += np.abs(
                np.sum(np.multiply(padded[x:x + 3, y:y + 3, 2], sobel135)))

            padded[x, y] = bound([int(r), int(g), int(b)])

    return padded
    def set(self, a_value):
        try:
            assert self.__mode == BufferedVariable.Mode.RW, \
                f"Режим переменной должен быть RW !! " \
                f"(Индекс: {self.__variable_info.index}.{self.__variable_info.bit_index})"

            if self.__is_bit:
                a_value = int(utils.bound(a_value, 0, 1))
                self.__calibrator.write_bit(self.__variable_info.index,
                                            self.__variable_info.bit_index,
                                            a_value)
            else:
                if self.__variable_info.c_type != 'd' and self.__variable_info.c_type != 'f':
                    a_value = int(a_value)

                _bytes = struct.pack(self.__variable_info.c_type, a_value)
                self.__calibrator.write_raw_bytes(self.__variable_info.index,
                                                  self.__variable_info.size,
                                                  _bytes)

            self.__buffer = a_value
            self.__delay_timer.start()
        except AssertionError as err:
            logging.debug(utils.exception_handler(err))
    def rough_step(self, a_step: float):
        self.settings[self.MEASURE_SECTION][self.STEP_ROUGH_KEY] = str(a_step)
        self.save()

        self.__rough_step = a_step
        self.__rough_step = utils.bound(self.__rough_step, 0., 100.)
Exemple #31
0
 def frequency(self, a_frequency: float):
     self.__frequency = utils.bound(a_frequency, clb.MIN_FREQUENCY, clb.MAX_FREQUENCY)
     self.__clb_dll.set_frequency(self.__frequency)
Exemple #32
0
def bound_frequency(a_frequency: float, a_signal_type: SignalType):
    min_frequency = MIN_FREQUENCY if is_ac_signal[a_signal_type] else 0
    max_frequency = MAX_FREQUENCY if is_ac_signal[a_signal_type] else 0
    return round(bound(a_frequency, min_frequency, max_frequency), 9)
Exemple #33
0
 def bound_input(self, a_value):
     return utils.bound(a_value, self.min_value, self.max_value)
    def restore_settings(self):
        if not os.path.exists(self.CONFIG_PATH):
            self.settings[self.MEASURE_SECTION] = {
                self.FIXED_STEP_KEY:
                self.FIXED_STEP_DEFAULT,
                self.FIXED_STEP_IDX_KEY:
                self.FIXED_STEP_IDX_DEFAULT,
                self.STEP_ROUGH_KEY:
                self.STEP_ROUGH_DEFAULT,
                self.STEP_COMMON_KEY:
                self.STEP_COMMON_DEFAULT,
                self.STEP_EXACT_KEY:
                self.STEP_EXACT_DEFAULT,
                self.START_DEVIATION_KEY:
                self.START_DEVIATION_DEFAULT,
                self.MOUSE_INVERSION_KEY:
                self.MOUSE_INVERSION_DEFAULT,
                self.DISABLE_SCROLL_ON_TABLE_KEY:
                self.DISABLE_SCROLL_ON_TABLE_DEFAULT
            }
            self.settings[self.PROTOCOL_SECTION] = {
                self.TEMPLATE_FILEPATH_KEY: "",
                self.SAVE_FOLDER_KEY: ""
            }
            utils.save_settings(self.CONFIG_PATH, self.settings)
        else:
            self.settings.read(self.CONFIG_PATH)
            self.add_ini_section(self.MEASURE_SECTION)
            self.add_ini_section(self.PROTOCOL_SECTION)

        self.__fixed_step_list = self.check_ini_value(
            self.MEASURE_SECTION, self.FIXED_STEP_KEY, self.FIXED_STEP_DEFAULT,
            self.ValueType.LIST_FLOAT)

        self.__fixed_step_idx = self.check_ini_value(
            self.MEASURE_SECTION, self.FIXED_STEP_IDX_KEY,
            self.FIXED_STEP_IDX_DEFAULT, self.ValueType.INT)
        self.__fixed_step_idx = utils.bound(self.__fixed_step_idx, 0,
                                            len(self.__fixed_step_list) - 1)

        self.__rough_step = self.check_ini_value(self.MEASURE_SECTION,
                                                 self.STEP_ROUGH_KEY,
                                                 self.STEP_ROUGH_DEFAULT,
                                                 self.ValueType.FLOAT)
        self.__rough_step = utils.bound(self.__rough_step, 0., 100.)

        self.__common_step = self.check_ini_value(self.MEASURE_SECTION,
                                                  self.STEP_COMMON_KEY,
                                                  self.STEP_COMMON_DEFAULT,
                                                  self.ValueType.FLOAT)
        self.__common_step = utils.bound(self.__common_step, 0., 100.)

        self.__exact_step = self.check_ini_value(self.MEASURE_SECTION,
                                                 self.STEP_EXACT_KEY,
                                                 self.STEP_EXACT_DEFAULT,
                                                 self.ValueType.FLOAT)
        self.__exact_step = utils.bound(self.__exact_step, 0., 100.)

        self.__start_deviation = self.check_ini_value(
            self.MEASURE_SECTION, self.START_DEVIATION_KEY,
            self.START_DEVIATION_DEFAULT, self.ValueType.INT)
        self.__start_deviation = utils.bound(self.__start_deviation, 0, 100)

        self.__mouse_inversion = self.check_ini_value(
            self.MEASURE_SECTION, self.MOUSE_INVERSION_KEY,
            self.MOUSE_INVERSION_DEFAULT, self.ValueType.INT)
        self.__mouse_inversion = utils.bound(self.__mouse_inversion, 0, 1)

        self.__disable_scroll_on_table = self.check_ini_value(
            self.MEASURE_SECTION, self.DISABLE_SCROLL_ON_TABLE_KEY,
            self.DISABLE_SCROLL_ON_TABLE_DEFAULT, self.ValueType.INT)
        self.__disable_scroll_on_table = utils.bound(
            self.__disable_scroll_on_table, 0, 1)

        self.__template_filepath = self.check_ini_value(
            self.PROTOCOL_SECTION, self.TEMPLATE_FILEPATH_KEY, "",
            self.ValueType.STRING)

        self.__save_folder = self.check_ini_value(self.PROTOCOL_SECTION,
                                                  self.SAVE_FOLDER_KEY, "",
                                                  self.ValueType.STRING)
    def common_step(self, a_step: float):
        self.settings[self.MEASURE_SECTION][self.STEP_COMMON_KEY] = str(a_step)
        self.save()

        self.__common_step = a_step
        self.__common_step = utils.bound(self.__common_step, 0., 100.)
    def exact_step(self, a_step: float):
        self.settings[self.MEASURE_SECTION][self.STEP_EXACT_KEY] = str(a_step)
        self.save()

        self.__exact_step = a_step
        self.__exact_step = utils.bound(self.__exact_step, 0., 100.)