Fix all problems with duplicated items

Author: qarmin

czkawka_core/src/similar_images.rs

@@ -683,50 +683,19 @@ impl SimilarImages {
         mem::swap(&mut all_hashed_images, &mut self.image_hashes);
 
         let all_hashes: Vec<_> = all_hashed_images.keys().collect();
-        let mut already_used_hashes: HashSet<_> = Default::default(); // List of already user hashes
-
-        for (hash, vec_file_entry) in all_hashed_images.clone() {
-            // There exists 2 or more images with same hash
-            if vec_file_entry.len() >= 2 {
-                already_used_hashes.insert(hash.clone());
-                collected_similar_images.insert(hash, vec_file_entry);
-            } else {
-                self.bktree.add(hash.clone());
-            }
-        }
-
-        //// PROGRESS THREAD START
-        let check_was_stopped = AtomicBool::new(false); // Used for breaking from GUI and ending check thread
-        let progress_thread_run = Arc::new(AtomicBool::new(true));
-
-        let atomic_mode_counter = Arc::new(AtomicUsize::new(0));
 
-        let progress_thread_handle = if let Some(progress_sender) = progress_sender {
-            let progress_send = progress_sender.clone();
-            let progress_thread_run = progress_thread_run.clone();
-            let atomic_mode_counter = atomic_mode_counter.clone();
-            let all_hashes_number = all_hashes.len();
-            thread::spawn(move || loop {
-                progress_send
-                    .unbounded_send(ProgressData {
-                        current_stage: 2,
-                        max_stage: 3,
-                        images_checked: atomic_mode_counter.load(Ordering::Relaxed) as usize,
-                        images_to_check: all_hashes_number,
-                    })
-                    .unwrap();
-                if !progress_thread_run.load(Ordering::Relaxed) {
-                    break;
+        // Checking entries with tolerance 0 is really easy and fast, because only entries with same hashes needs to be checked
+        if tolerance == 0 {
+            for (hash, vec_file_entry) in all_hashed_images.clone() {
+                if vec_file_entry.len() >= 2 {
+                    collected_similar_images.insert(hash, vec_file_entry);
                 }
-                sleep(Duration::from_millis(LOOP_DURATION as u64));
-            })
+            }
         } else {
-            thread::spawn(|| {})
-        };
-        //// PROGRESS THREAD END
-        let mut timer = SystemTime::now();
+            for hash in &all_hashes {
+                self.bktree.add(hash.to_vec());
+            }
 
-        if tolerance > 0 {
             let number_of_processors = num_cpus::get();
             let chunks = all_hashes.chunks(all_hashes.len() / number_of_processors);
 
@@ -790,13 +759,12 @@ impl SimilarImages {
                         }
                     }
 
+                    #[cfg(debug_assertions)]
                     debug_check_for_duplicated_things(hashes_parents.clone(), hashes_similarity.clone(), all_hashed_images.clone(), "BEFORE");
 
                     (hashes_parents, hashes_similarity)
                 })
                 .collect();
-            Common::print_time(timer, SystemTime::now(), "CHECKING IN PARRAREL".to_string());
-            timer = SystemTime::now();
 
             {
                 let mut new_hashes_parents: HashMap<&Vec<u8>, u32> = Default::default();
@@ -847,9 +815,8 @@ impl SimilarImages {
                         }
                     }
                 }
-                Common::print_time(timer, SystemTime::now(), "Connecting results".to_string());
-                timer = SystemTime::now();
 
+                #[cfg(debug_assertions)]
                 debug_check_for_duplicated_things(new_hashes_parents.clone(), new_hashes_similarity.clone(), all_hashed_images.clone(), "LATTER");
 
                 // Collecting results
@@ -868,12 +835,11 @@ impl SimilarImages {
                     }
                     collected_similar_images.get_mut(parent_hash).unwrap().append(&mut vec_fe);
                 }
-                Common::print_time(timer, SystemTime::now(), "Creating entries".to_string());
             }
         }
 
         // Validating if group contains duplicated results
-        //#[cfg(debug_assertions)]
+        #[cfg(debug_assertions)]
         {
             let mut result_hashset: HashSet<String> = Default::default();
             let mut found = false;