From b6d0eb050834cd5ea8310aa755bf96196023a6af Mon Sep 17 00:00:00 2001 From: doryan Date: Fri, 19 Apr 2024 01:30:51 +0400 Subject: [PATCH] ADDED: models and controllers for page "signal reducing"\n TODO: done table for page "signal reducing" --- .../model_utils/hamming_code_seven_four.rs | 44 +++++---- src/controller/model_utils/mod.rs | 4 +- src/controller/model_utils/signal_reducer.rs | 15 +++ .../view_utils/hamming_code_input_utils.rs | 41 +++++++++ src/controller/view_utils/input_utils.rs | 38 ++------ src/controller/view_utils/mod.rs | 5 +- .../view_utils/signal_reduce_input_utils.rs | 63 +++++++++++++ src/model/model.rs | 10 +- src/view/components/input.rs | 9 ++ src/view/pages/hamming_code.rs | 4 +- src/view/pages/signal_reducing.rs | 92 +++++++++++-------- 11 files changed, 228 insertions(+), 97 deletions(-) create mode 100644 src/controller/model_utils/signal_reducer.rs create mode 100644 src/controller/view_utils/hamming_code_input_utils.rs create mode 100644 src/controller/view_utils/signal_reduce_input_utils.rs diff --git a/src/controller/model_utils/hamming_code_seven_four.rs b/src/controller/model_utils/hamming_code_seven_four.rs index 15ae669..6022c63 100644 --- a/src/controller/model_utils/hamming_code_seven_four.rs +++ b/src/controller/model_utils/hamming_code_seven_four.rs @@ -1,6 +1,9 @@ use std::collections::HashMap; -use crate::{controller::view_utils::input_utils::*, model::model::*}; +use crate::{ + controller::view_utils::{hamming_code_input_utils::*, input_utils::*}, + model::model::*, +}; /// **Синдромы** /// @@ -23,7 +26,8 @@ pub fn hamming(raw_input: String, mode: HammingMode) -> Result { let prepared_input: String = processing_input(&raw_input); - let (fc, sc) = check_correct_input(&raw_input, &prepared_input, length_of_code); + let (fc, sc): (bool, bool) = + check_correct_binary_code(&raw_input, &prepared_input, length_of_code); if !fc || !sc { Err("Ошибка. Проверьте корректность ввода.".to_string()) @@ -45,7 +49,7 @@ pub fn hamming_encrypt_data(data: &Vec, result_string: &mut String, length_o let mut i: usize = length_of_code; while i <= data.len() { - let data_bits = &data[i - length_of_code..i]; + let data_bits: &[u8] = &data[i - length_of_code..i]; let (check_bit_1, check_bit_2, check_bit_3) = ( data_bits[0] ^ data_bits[1] ^ data_bits[3], data_bits[0] ^ data_bits[2] ^ data_bits[3], @@ -87,30 +91,32 @@ pub fn hamming_decrypt_data(data: &Vec, result_string: &mut String, length_o general_length += length_of_code; continue; } else { - let error_position = syndromes + let error_position: &usize = syndromes .iter() .find(move |&(&_error_position, &error)| error == checked_bits) .unwrap() .0; - let correctly_code: Vec = data_bits - .iter() - .enumerate() - .map(|(index, bit)| { - if index == error_position - 1 { - (*bit == 0u8).into() - } else { - *bit - } - }) - .collect(); + let uncorrect_code: String = from_vec_bits_to_string(&data_bits); + let correct_code: String = from_vec_bits_to_string( + data_bits + .iter() + .enumerate() + .map(|(index, &bit)| { + if index == error_position - 1 { + (bit == 0u8).into() + } else { + bit + } + }) + .collect::>() + .as_slice(), + ); let error = format!( - "Ошибка в коде {} {:?}, позиция ошибки {}, корректный код: {:?}; \n", + "Ошибка в коде {} [{uncorrect_code}], позиция ошибки {}, корректный код: [{correct_code}]; \n", general_length / 7, - &data_bits, - error_position, - correctly_code + error_position ); errors.push_str(error.as_str()); diff --git a/src/controller/model_utils/mod.rs b/src/controller/model_utils/mod.rs index a9207ce..905a630 100644 --- a/src/controller/model_utils/mod.rs +++ b/src/controller/model_utils/mod.rs @@ -1 +1,3 @@ -pub mod hamming_code_seven_four; \ No newline at end of file +pub mod hamming_code_seven_four; +pub mod signal_reducer; + diff --git a/src/controller/model_utils/signal_reducer.rs b/src/controller/model_utils/signal_reducer.rs new file mode 100644 index 0000000..e7faab6 --- /dev/null +++ b/src/controller/model_utils/signal_reducer.rs @@ -0,0 +1,15 @@ +pub fn reactive_resistance_of_capacitor(Cm: f64, L: f64, f: f64) -> f64 { + 1f64 / (2f64 * 3.14f64 * f * Cm * L) +} + +pub fn full_resistance_of_capacitor(Xc: f64, Rs: f64, Rm: f64, L: f64) -> f64 { + (Xc.powf(2f64) + (Rs + Rm * L).powf(2f64)).sqrt() +} + +pub fn voltage_from_signal_source(Vs: f64, Xc: f64, Z: f64) -> f64 { + (Vs * Xc) / Z +} + +pub fn coef_of_signal_reduce(Vs: f64, V: f64) -> f64 { + Vs / V +} diff --git a/src/controller/view_utils/hamming_code_input_utils.rs b/src/controller/view_utils/hamming_code_input_utils.rs new file mode 100644 index 0000000..8a408f0 --- /dev/null +++ b/src/controller/view_utils/hamming_code_input_utils.rs @@ -0,0 +1,41 @@ +use gtk4 as gtk; + +use crate::{model::model::*, model_utils::hamming_code_seven_four::*}; +use gtk::{prelude::*, *}; + +pub fn start_hamming_algorithm(input: &TextView, output: &TextView, mode: bool) -> () { + let (iter_start, iter_end) = input.buffer().bounds(); + let parsed_input: String = input + .buffer() + .text(&iter_start, &iter_end, false) + .to_string() + .trim() + .parse() + .unwrap(); + + let operation = if mode == false { + HammingMode::Encrypt + } else { + HammingMode::Decrypt + }; + + match hamming(parsed_input, operation) { + Ok(res) => output.buffer().set_text(res.trim_end()), + Err(rej) => output.buffer().set_text(rej.as_str()), + } +} + +pub fn check_correct_binary_code( + input: &String, + prepared_input: &String, + l: usize, +) -> (bool, bool) { + let first_condition: bool = input + .as_str() + .chars() + .all(|c| c == '1' || c == '0' || c == ' '); + + let second_condition: bool = prepared_input.len() % l == 0; + + (first_condition, second_condition) +} diff --git a/src/controller/view_utils/input_utils.rs b/src/controller/view_utils/input_utils.rs index d17ed71..3157df7 100644 --- a/src/controller/view_utils/input_utils.rs +++ b/src/controller/view_utils/input_utils.rs @@ -4,29 +4,7 @@ use bitvec::{order::Lsb0, view::AsBits}; use gtk::{prelude::*, *}; use std::ops::Deref; -use crate::{model::model::*, model_utils::hamming_code_seven_four::*}; - -pub fn parse_input(input: &TextView, output: &TextView, mode: bool) -> () { - let (iter_start, iter_end) = input.buffer().bounds(); - let parsed_input: String = input - .buffer() - .text(&iter_start, &iter_end, false) - .to_string() - .trim() - .parse() - .unwrap(); - - let operation = if mode == false { - HammingMode::Encrypt - } else { - HammingMode::Decrypt - }; - - match hamming(parsed_input, operation) { - Ok(res) => output.buffer().set_text(res.trim_end()), - Err(rej) => output.buffer().set_text(rej.as_str()), - } -} +const ASCII_ZERO_CHAR_POSITION: u8 = 48; pub fn processing_input(input: &String) -> String { input @@ -35,15 +13,11 @@ pub fn processing_input(input: &String) -> String { .fold(String::new(), |c: String, n: &str| c + n) } -pub fn check_correct_input(input: &String, prepared_input: &String, l: usize) -> (bool, bool) { - let first_condition = input - .as_str() - .chars() - .all(|c| c == '1' || c == '0' || c == ' '); - - let second_condition = prepared_input.len() % l == 0; - - (first_condition, second_condition) +pub fn from_vec_bits_to_string(raw_data: &[u8]) -> String { + raw_data + .iter() + .map(|bit| -> char { (bit + ASCII_ZERO_CHAR_POSITION).into() }) + .collect() } pub fn from_string_to_vec_bits(raw_data: String) -> Vec { diff --git a/src/controller/view_utils/mod.rs b/src/controller/view_utils/mod.rs index 2973e77..de190f2 100644 --- a/src/controller/view_utils/mod.rs +++ b/src/controller/view_utils/mod.rs @@ -1 +1,4 @@ -pub mod input_utils; \ No newline at end of file +pub mod hamming_code_input_utils; +pub mod input_utils; +pub mod signal_reduce_input_utils; + diff --git a/src/controller/view_utils/signal_reduce_input_utils.rs b/src/controller/view_utils/signal_reduce_input_utils.rs new file mode 100644 index 0000000..31d2a18 --- /dev/null +++ b/src/controller/view_utils/signal_reduce_input_utils.rs @@ -0,0 +1,63 @@ +use gtk4 as gtk; + +use crate::model::model::SchemeCharacteristics; +use gtk::{prelude::*, *}; + +pub fn check_characteristics( + raw_characteristics: &Vec, + all_inputs_data: &mut Vec, + output: &mut String, +) -> bool { + for input in raw_characteristics { + let (iter_start, iter_end) = input.buffer().bounds(); + let parsed_input: Result = input + .buffer() + .text(&iter_start, &iter_end, false) + .to_string() + .trim() + .parse(); + + match parsed_input { + Ok(int) => { + all_inputs_data.push(int); + println!("{:?}", int); + } + Err(err) => { + if output.len() == 0 { + output.push_str("Введите пожалуйста числа в полях"); + println!("{:?}", err); + } + } + } + } + + if output.len() != 0 { + false + } else { + true + } +} + +pub fn start_algorithm(error_log_label: &Label, raw_characteristics: &Vec) { + let mut all_inputs_data: Vec = Vec::new(); + let mut output: String = String::new(); + + if let false = check_characteristics(raw_characteristics, &mut all_inputs_data, &mut output) { + error_log_label.set_text(output.as_str()); + } else { + error_log_label.set_text(""); + + let (L, Rm, Cm, Vs, Rs, f): SchemeCharacteristics = ( + all_inputs_data[0], + all_inputs_data[1], + all_inputs_data[2], + all_inputs_data[3], + all_inputs_data[4], + all_inputs_data[5], + ); + + let mut frequencies: Vec = vec![f as usize, 1usize]; + + frequencies.append(&mut (0..100).step_by(5).collect()); + } +} diff --git a/src/model/model.rs b/src/model/model.rs index 30561da..c9fd331 100644 --- a/src/model/model.rs +++ b/src/model/model.rs @@ -1,11 +1,13 @@ #[repr(usize)] #[derive(Clone)] -pub enum HammingMode{ +pub enum HammingMode { Encrypt = 4, - Decrypt = 7 + Decrypt = 7, } -pub struct EventHandler{ +pub struct EventHandler { pub(crate) component: C, pub(crate) callback: F, -} \ No newline at end of file +} + +pub type SchemeCharacteristics = (f64, f64, f64, f64, f64, f64); diff --git a/src/view/components/input.rs b/src/view/components/input.rs index 9dd4060..76a115a 100644 --- a/src/view/components/input.rs +++ b/src/view/components/input.rs @@ -5,8 +5,10 @@ use gtk::{prelude::*, *}; pub type InputLabel = String; +#[derive(Clone)] pub struct Input { component: Box, + input: TextView, } pub struct InputBuilder { @@ -32,6 +34,12 @@ impl Product for Input { } } +impl Input { + pub fn get_input(self) -> TextView { + self.input + } +} + impl InputBuilder { pub fn set_label(mut self, label: &str) -> Self { self.label = String::from(label); @@ -78,6 +86,7 @@ impl InputBuilder { Input { component: input_component, + input: text_view_input, } } } diff --git a/src/view/pages/hamming_code.rs b/src/view/pages/hamming_code.rs index 7a4f0de..a5d59ba 100644 --- a/src/view/pages/hamming_code.rs +++ b/src/view/pages/hamming_code.rs @@ -4,7 +4,7 @@ use crate::{ controller::{ controller::*, event_handlers::{button_event_handlers::*, switch_event_handlers::*}, - view_utils::input_utils::*, + view_utils::{hamming_code_input_utils::*, input_utils::*}, }, model::model::*, view::{components::wrapper::*, properties::*}, @@ -94,7 +94,7 @@ pub fn hamming_code_page(wrapper: &Box) -> () { .on_click(); EventHandler::new(hamming_crypt_button.clone(), move |_button: &Button| { - parse_input( + start_hamming_algorithm( &text_view_input_for_parse, &text_view_output_for_output, crypt_mode_switch_to_handle.state(), diff --git a/src/view/pages/signal_reducing.rs b/src/view/pages/signal_reducing.rs index ddbb287..85aad95 100644 --- a/src/view/pages/signal_reducing.rs +++ b/src/view/pages/signal_reducing.rs @@ -2,11 +2,15 @@ use gtk4 as gtk; use crate::{ controller::event_handlers::button_event_handlers::*, - model::{builder_traits::Product, model::EventHandler}, + model::{ + builder_traits::Product, + model::{EventHandler, SchemeCharacteristics}, + }, view::{ components::{input::Input, wrapper::Wrapper}, properties::*, }, + view_utils::signal_reduce_input_utils::start_algorithm, }; use gtk::{prelude::*, Align, WrapMode, *}; @@ -19,26 +23,23 @@ pub fn signal_reducing_page(wrapper: &Box) { vertical: Align::Fill, }; - let wire_length_input = Input::builder() + let wire_length_input: Input = Input::builder() .set_label("l, м:") .set_margins(MarginData::EqualsMargin(5)) .set_align(input_label_alignment) - .build(monospace, input_wrapping, input_height) - .get(); + .build(monospace, input_wrapping, input_height); - let resistance_per_meter_input = Input::builder() + let resistance_per_meter_input: Input = Input::builder() .set_label("Rм, Ом:") .set_margins(MarginData::EqualsMargin(5)) .set_align(input_label_alignment) - .build(monospace, input_wrapping, input_height) - .get(); + .build(monospace, input_wrapping, input_height); - let capacity_per_meter_input = Input::builder() + let capacity_per_meter_input: Input = Input::builder() .set_label("Cм, пФ:") .set_margins(MarginData::EqualsMargin(5)) .set_align(input_label_alignment) - .build(monospace, input_wrapping, input_height) - .get(); + .build(monospace, input_wrapping, input_height); let wrapper_first_row = Wrapper::col_builder() .halign(Align::Fill) @@ -46,39 +47,38 @@ pub fn signal_reducing_page(wrapper: &Box) { .spacing(5) .build(); - let first_row_elements: Vec<&Box> = vec![ + let first_row_elements: Vec<&Input> = vec![ &wire_length_input, &resistance_per_meter_input, &capacity_per_meter_input, ]; for elem in first_row_elements { - elem.set_halign(input_alignment); - elem.set_hexpand(true); + let input: Box = elem.clone().get(); - wrapper_first_row.append(elem); + input.set_halign(input_alignment); + input.set_hexpand(true); + + wrapper_first_row.append(&input); } - let info_signal_voltage_input = Input::builder() + let info_signal_voltage_input: Input = Input::builder() .set_label("Vи, мВ:") .set_margins(MarginData::EqualsMargin(5)) .set_align(input_label_alignment) - .build(monospace, input_wrapping, input_height) - .get(); + .build(monospace, input_wrapping, input_height); - let resistance_of_info_voltage_source_input = Input::builder() + let resistance_of_info_voltage_source_input: Input = Input::builder() .set_label("Rи, Ом:") .set_margins(MarginData::EqualsMargin(5)) .set_align(input_label_alignment) - .build(monospace, input_wrapping, input_height) - .get(); + .build(monospace, input_wrapping, input_height); - let info_voltage_source_frequency_input = Input::builder() + let info_voltage_source_frequency_input: Input = Input::builder() .set_label("f, мГц:") .set_margins(MarginData::EqualsMargin(5)) .set_align(input_label_alignment) - .build(monospace, input_wrapping, input_height) - .get(); + .build(monospace, input_wrapping, input_height); let wrapper_second_row = Wrapper::col_builder() .halign(Align::Fill) @@ -86,19 +86,30 @@ pub fn signal_reducing_page(wrapper: &Box) { .spacing(5) .build(); - let second_row_elements: Vec<&Box> = vec![ + let second_row_elements: Vec<&Input> = vec![ &info_signal_voltage_input, &resistance_of_info_voltage_source_input, &info_voltage_source_frequency_input, ]; for elem in second_row_elements { - elem.set_halign(input_alignment); - elem.set_hexpand(true); + let input: Box = elem.clone().get(); - wrapper_second_row.append(elem); + input.set_halign(input_alignment); + input.set_hexpand(true); + + wrapper_second_row.append(&input); } + let all_text_views: Vec = vec![ + wire_length_input.get_input(), + resistance_per_meter_input.get_input(), + capacity_per_meter_input.get_input(), + info_signal_voltage_input.get_input(), + resistance_of_info_voltage_source_input.get_input(), + info_voltage_source_frequency_input.get_input(), + ]; + let main_wrapper = Wrapper::row_builder().spacing(5).build(); main_wrapper.append(&wrapper_first_row); @@ -112,20 +123,21 @@ pub fn signal_reducing_page(wrapper: &Box) { let table_header_labels = vec!["f, Гц", "Xc, пФ", "Vп, мВ", "ζ"]; - let table_header = Wrapper::col_builder() - .height_request(24) - .spacing(5) - .halign(Align::Center) + let table_header = ColumnView::builder() + .focusable(false) + .reorderable(true) + .halign(Align::Fill) .hexpand(true) .build(); - for header_label in table_header_labels { - let label = Label::builder() - .label(header_label) - .halign(Align::Fill) - .hexpand(true) + for table_header_label in table_header_labels { + let column = ColumnViewColumn::builder() + .title(table_header_label) + .fixed_width(200) + .expand(true) .build(); - table_header.append(&label); + + table_header.append_column(&column); } let table_of_calculated_values = Frame::builder() @@ -136,13 +148,17 @@ pub fn signal_reducing_page(wrapper: &Box) { .set_margin(MarginData::MultipleMargin((10, 5, 0, 0))) .build(); + let errors_label: Label = Label::new(Some("")); + let errors_label_for_handler: Label = errors_label.clone(); + EventHandler::new(calculate_button.clone(), move |_| { - println!("button taped"); + start_algorithm(&errors_label_for_handler, &all_text_views) }) .on_click(); main_wrapper.append(&calculate_button); main_wrapper.append(&table_of_calculated_values); + main_wrapper.append(&errors_label); wrapper.append(&main_wrapper); }