warricksothr
/
Perceptual-Image-Hashing
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Browse Source

Ran rustfmt

develop
Drew Short 8 years ago
parent
e0a951ee3c
commit
dc8453dc67
7 changed files with 433 additions and 346 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 73
      src/cache.rs
  2. 4
      src/hash/ahash.rs
  3. 4
      src/hash/dhash.rs
  4. 15
      src/hash/mod.rs
  5. 13
      src/hash/phash.rs
  6. 93
      src/lib.rs
  7. 3
      src/main.rs

73
src/cache.rs
View File

@ -34,7 +34,9 @@ struct CacheMetadata {
}
impl Default for CacheMetadata {
fn default() -> CacheMetadata { CacheMetadata { cache_version: CACHE_VERSION } }
fn default() -> CacheMetadata {
CacheMetadata { cache_version: CACHE_VERSION }
}
}
impl PartialEq<CacheMetadata> for CacheMetadata {
@ -56,7 +58,12 @@ pub struct Cache<'a> {
}
impl<'a> Default for Cache<'a> {
fn default() -> Cache<'a> { Cache {cache_dir: CACHE_DIR, use_cache: true } }
fn default() -> Cache<'a> {
Cache {
cache_dir: CACHE_DIR,
use_cache: true,
}
}
}
impl<'a> Cache<'a> {
@ -75,7 +82,8 @@ impl<'a> Cache<'a> {
let mut loaded_metadata_string = String::new();
match file.read_to_string(&mut loaded_metadata_string) {
Ok(_) => {
let loaded_metadata: CacheMetadata = match json::decode(&loaded_metadata_string) {
let loaded_metadata: CacheMetadata =
match json::decode(&loaded_metadata_string) {
Ok(data) => data,
Err(_) => CacheMetadata { cache_version: 0 },
};
@ -89,26 +97,27 @@ impl<'a> Cache<'a> {
Ok(_) => (),
Err(e) => println!("Error: {}", e),
}
},
}
Err(e) => println!("Error: {}", e),
};
};
},
}
Err(e) => println!("Error: {}", e),
};
},
// Metadata file doesn't exist, do nothing assume all is well, create new metadata file
Err(_) => {},
}
// Metadata file doesn't exist, do nothing assume all is well,
// create new metadata file
Err(_) => {}
};
let encoded_cache_metadata = json::encode(&current_metadata).unwrap();
match File::create(&metadata_path) {
Ok(mut file) => {
let _ = file.write(&encoded_cache_metadata.as_bytes());
Ok(())
},
Err(e) => Err(e)
}
},
Err(e) => Err(e),
}
}
Err(e) => Err(e),
}
}
@ -162,7 +171,7 @@ impl<'a> Cache<'a> {
return Err(e);
}
}
},
}
Err(e) => println!("Error: {}", e),
}
}
@ -209,7 +218,9 @@ impl<'a> Cache<'a> {
None
}
}
} else { None }
} else {
None
}
}
/**
@ -223,7 +234,12 @@ impl<'a> Cache<'a> {
let hash = self.get_file_hash(&path);
match hash {
Ok(sha1) => {
let cache_path_str = format!("{}/matrix/{}x{}/{}.{}", self.cache_dir, size, size, sha1, CACHED_MATRIX_EXT);
let cache_path_str = format!("{}/matrix/{}x{}/{}.{}",
self.cache_dir,
size,
size,
sha1,
CACHED_MATRIX_EXT);
let cache_dir_str = format!("{}/matrix/{}x{}", self.cache_dir, size, size);
match create_dir_all(cache_dir_str) {
Ok(_) => {
@ -231,10 +247,14 @@ impl<'a> Cache<'a> {
// Save the file into the cache
match File::create(&cached_path) {
Ok(mut file) => {
let mut compressor = ZlibEncoder::new(Vec::new(), Compression::Default);
let mut compressor = ZlibEncoder::new(Vec::new(),
Compression::Default);
for row in file_contents {
let mut row_str = row.iter().fold(String::new(),
|acc, &item| acc + &format!("{},", item));
|acc, &item| {
acc +
&format!("{},", item)
});
// remove the last comma
let desire_len = row_str.len() - 1;
row_str.truncate(desire_len);
@ -255,7 +275,7 @@ impl<'a> Cache<'a> {
return Err(e);
}
}
},
}
Err(e) => println!("Error: {}", e),
}
}
@ -270,16 +290,18 @@ impl<'a> Cache<'a> {
/**
* Get a matrix out of the cache
*/
pub fn get_matrix_from_cache(&self,
path: &Path,
size: u32)
-> Option<Vec<Vec<f64>>> {
pub fn get_matrix_from_cache(&self, path: &Path, size: u32) -> Option<Vec<Vec<f64>>> {
if self.use_cache {
let hash = self.get_file_hash(&path);
match hash {
Ok(sha1) => {
// Check if the file exists in the cache
let cache_path_str = format!("{}/matrix/{}x{}/{}.{}", CACHE_DIR, size, size, sha1, CACHED_MATRIX_EXT);
let cache_path_str = format!("{}/matrix/{}x{}/{}.{}",
CACHE_DIR,
size,
size,
sha1,
CACHED_MATRIX_EXT);
let cached_path = Path::new(&cache_path_str);
// Try to open, if it does, then we can read the image in
match File::open(&cached_path) {
@ -299,7 +321,8 @@ impl<'a> Cache<'a> {
.map(|line| {
line.split(",")
.map(|f| {
f64::from_str(f).unwrap()
f64::from_str(f)
.unwrap()
})
.collect()
})
@ -317,7 +340,9 @@ impl<'a> Cache<'a> {
None
}
}
} else { None }
} else {
None
}
}
}

4
src/hash/ahash.rs
View File

@ -15,7 +15,9 @@ pub struct AHash<'a> {
impl<'a> AHash<'a> {
pub fn new(path: &'a Path, precision: &Precision, cache: &'a Cache) -> Self {
AHash { prepared_image: Box::new(prepare_image(&path, &HashType::AHash, &precision, &cache)) }
AHash {
prepared_image: Box::new(prepare_image(&path, &HashType::AHash, &precision, &cache)),
}
}
}

4
src/hash/dhash.rs
View File

@ -15,7 +15,9 @@ pub struct DHash<'a> {
impl<'a> DHash<'a> {
pub fn new(path: &'a Path, precision: &Precision, cache: &'a Cache) -> Self {
DHash { prepared_image: Box::new(prepare_image(&path, &HashType::DHash, &precision, &cache)) }
DHash {
prepared_image: Box::new(prepare_image(&path, &HashType::DHash, &precision, &cache)),
}
}
}

15
src/hash/mod.rs
View File

@ -128,7 +128,7 @@ pub fn prepare_image<'a>(path: &'a Path,
PreparedImage {
orig_path: &*image_path,
image: image,
cache: &cache
cache: &cache,
}
}
None => {
@ -152,18 +152,25 @@ pub fn prepare_image<'a>(path: &'a Path,
/**
* Get a specific HashType hash
*/
pub fn get_perceptual_hash<'a>(path: &'a Path, precision: &Precision, hash_type: &HashType, cache: &Cache) -> u64 {
pub fn get_perceptual_hash<'a>(path: &'a Path,
precision: &Precision,
hash_type: &HashType,
cache: &Cache)
-> u64 {
match *hash_type {
HashType::AHash => ahash::AHash::new(&path, &precision, &cache).get_hash(),
HashType::DHash => dhash::DHash::new(&path, &precision, &cache).get_hash(),
HashType::PHash => phash::PHash::new(&path, &precision, &cache).get_hash()
HashType::PHash => phash::PHash::new(&path, &precision, &cache).get_hash(),
}
}
/**
* Get all perceptual hashes for an image
*/
pub fn get_perceptual_hashes<'a>(path: &'a Path, precision: &Precision, cache: &Cache) -> PerceptualHashes<'a> {
pub fn get_perceptual_hashes<'a>(path: &'a Path,
precision: &Precision,
cache: &Cache)
-> PerceptualHashes<'a> {
let image_path = path.to_str().unwrap();
let ahash = ahash::AHash::new(&path, &precision, &cache).get_hash();
let dhash = dhash::DHash::new(&path, &precision, &cache).get_hash();

13
src/hash/phash.rs
View File

@ -17,7 +17,9 @@ pub struct PHash<'a> {
impl<'a> PHash<'a> {
pub fn new(path: &'a Path, precision: &Precision, cache: &'a Cache) -> Self {
PHash { prepared_image: Box::new(prepare_image(&path, &HashType::PHash, &precision, &cache)) }
PHash {
prepared_image: Box::new(prepare_image(&path, &HashType::PHash, &precision, &cache)),
}
}
}
@ -39,8 +41,9 @@ impl<'a> PerceptualHash for PHash<'a> {
// Pretty fast already, so caching doesn't make a huge difference
// Atleast compared to opening and processing the images
let mut data_matrix: Vec<Vec<f64>> = Vec::new();
match self.prepared_image.cache.get_matrix_from_cache(&Path::new(self.prepared_image.orig_path),
width as u32) {
match self.prepared_image
.cache
.get_matrix_from_cache(&Path::new(self.prepared_image.orig_path), width as u32) {
Some(matrix) => data_matrix = matrix,
None => {
// Preparing the results
@ -60,7 +63,9 @@ impl<'a> PerceptualHash for PHash<'a> {
// Perform the 2D DFT operation on our matrix
calculate_2d_dft(&mut data_matrix);
// Store this DFT in the cache
match self.prepared_image.cache.put_matrix_in_cache(&Path::new(self.prepared_image.orig_path),
match self.prepared_image
.cache
.put_matrix_in_cache(&Path::new(self.prepared_image.orig_path),
width as u32,
&data_matrix) {
Ok(_) => {}

93
src/lib.rs
View File

@ -13,7 +13,10 @@ use std::path::Path;
use std::ffi::CStr;
use cache::Cache;
static LIB_CACHE: Cache<'static> = Cache { cache_dir: cache::CACHE_DIR, use_cache: true };
static LIB_CACHE: Cache<'static> = Cache {
cache_dir: cache::CACHE_DIR,
use_cache: true,
};
/**
* Prepare the library for work.
@ -45,15 +48,24 @@ static LIB_CACHE: Cache<'static> = Cache { cache_dir: cache::CACHE_DIR, use_cach
pub fn get_ahash(path: &Path) -> u64 {
hash::get_perceptual_hash(&path, &hash::Precision::Medium, &hash::HashType::AHash, &LIB_CACHE)
hash::get_perceptual_hash(&path,
&hash::Precision::Medium,
&hash::HashType::AHash,
&LIB_CACHE)
}
pub fn get_dhash(path: &Path) -> u64 {
hash::get_perceptual_hash(&path, &hash::Precision::Medium, &hash::HashType::DHash, &LIB_CACHE)
hash::get_perceptual_hash(&path,
&hash::Precision::Medium,
&hash::HashType::DHash,
&LIB_CACHE)
}
pub fn get_phash(path: &Path) -> u64 {
hash::get_perceptual_hash(&path, &hash::Precision::Medium, &hash::HashType::DHash, &LIB_CACHE)
hash::get_perceptual_hash(&path,
&hash::Precision::Medium,
&hash::HashType::DHash,
&LIB_CACHE)
}
pub fn get_hamming_distance(hash1: u64, hash2: u64) -> u64 {
@ -170,7 +182,10 @@ static LIB_CACHE: Cache<'static> = Cache { cache_dir: cache::CACHE_DIR, use_cach
image_hashes: [u64; 3]) {
for index in 0..image_paths.len() {
let image_path = image_paths[index];
let calculated_hash = hash::get_perceptual_hash(&image_path, &hash_precision, &hash_type, &super::LIB_CACHE);
let calculated_hash = hash::get_perceptual_hash(&image_path,
&hash_precision,
&hash_type,
&super::LIB_CACHE);
println!("Image hashes for '{}': expected: {} actual: {}",
image_path.to_str().unwrap(),
image_hashes[index],
@ -188,10 +203,11 @@ static LIB_CACHE: Cache<'static> = Cache { cache_dir: cache::CACHE_DIR, use_cach
let sample_01_images: [&Path; 3] = [&Path::new("./test_images/sample_01_large.jpg"),
&Path::new("./test_images/sample_01_medium.jpg"),
&Path::new("./test_images/sample_01_small.jpg")];
let sample_01_hashes: [u64; 3] = [857051991849750,
857051991849750,
857051991849750];
test_imageset_hash(hash::HashType::AHash, hash::Precision::Medium, sample_01_images, sample_01_hashes);
let sample_01_hashes: [u64; 3] = [857051991849750, 857051991849750, 857051991849750];
test_imageset_hash(hash::HashType::AHash,
hash::Precision::Medium,
sample_01_images,
sample_01_hashes);
// Sample_02 tests
let sample_02_images: [&Path; 3] = [&Path::new("./test_images/sample_02_large.jpg"),
@ -200,7 +216,10 @@ static LIB_CACHE: Cache<'static> = Cache { cache_dir: cache::CACHE_DIR, use_cach
let sample_02_hashes: [u64; 3] = [18446744073441116160,
18446744073441116160,
18446744073441116160];
test_imageset_hash(hash::HashType::AHash, hash::Precision::Medium, sample_02_images, sample_02_hashes);
test_imageset_hash(hash::HashType::AHash,
hash::Precision::Medium,
sample_02_images,
sample_02_hashes);
// Sample_03 tests
let sample_03_images: [&Path; 3] = [&Path::new("./test_images/sample_03_large.jpg"),
@ -209,7 +228,10 @@ static LIB_CACHE: Cache<'static> = Cache { cache_dir: cache::CACHE_DIR, use_cach
let sample_03_hashes: [u64; 3] = [135670932300497406,
135670932300497406,
135670932300497406];
test_imageset_hash(hash::HashType::AHash, hash::Precision::Medium, sample_03_images, sample_03_hashes);
test_imageset_hash(hash::HashType::AHash,
hash::Precision::Medium,
sample_03_images,
sample_03_hashes);
// Sample_04 tests
let sample_04_images: [&Path; 3] = [&Path::new("./test_images/sample_04_large.jpg"),
@ -218,7 +240,10 @@ static LIB_CACHE: Cache<'static> = Cache { cache_dir: cache::CACHE_DIR, use_cach
let sample_04_hashes: [u64; 3] = [18446460933225054208,
18446460933090836480,
18446460933090836480];
test_imageset_hash(hash::HashType::AHash, hash::Precision::Medium, sample_04_images, sample_04_hashes);
test_imageset_hash(hash::HashType::AHash,
hash::Precision::Medium,
sample_04_images,
sample_04_hashes);
// Clean_Cache
// super::teardown();
@ -236,7 +261,10 @@ static LIB_CACHE: Cache<'static> = Cache { cache_dir: cache::CACHE_DIR, use_cach
let sample_01_hashes: [u64; 3] = [7937395827556495926,
7937395827556495926,
7939647627370181174];
test_imageset_hash(hash::HashType::DHash, hash::Precision::Medium, sample_01_images, sample_01_hashes);
test_imageset_hash(hash::HashType::DHash,
hash::Precision::Medium,
sample_01_images,
sample_01_hashes);
// Sample_02 tests
let sample_02_images: [&Path; 3] = [&Path::new("./test_images/sample_02_large.jpg"),
@ -245,7 +273,10 @@ static LIB_CACHE: Cache<'static> = Cache { cache_dir: cache::CACHE_DIR, use_cach
let sample_02_hashes: [u64; 3] = [11009829669713008949,
11009829670249879861,
11009829669713008949];
test_imageset_hash(hash::HashType::DHash, hash::Precision::Medium, sample_02_images, sample_02_hashes);
test_imageset_hash(hash::HashType::DHash,
hash::Precision::Medium,
sample_02_images,
sample_02_hashes);
// Sample_03 tests
let sample_03_images: [&Path; 3] = [&Path::new("./test_images/sample_03_large.jpg"),
@ -254,7 +285,10 @@ static LIB_CACHE: Cache<'static> = Cache { cache_dir: cache::CACHE_DIR, use_cach
let sample_03_hashes: [u64; 3] = [225528496439353286,
225528496439353286,
226654396346195908];
test_imageset_hash(hash::HashType::DHash, hash::Precision::Medium, sample_03_images, sample_03_hashes);
test_imageset_hash(hash::HashType::DHash,
hash::Precision::Medium,
sample_03_images,
sample_03_hashes);
// Sample_04 tests
let sample_04_images: [&Path; 3] = [&Path::new("./test_images/sample_04_large.jpg"),
@ -263,7 +297,10 @@ static LIB_CACHE: Cache<'static> = Cache { cache_dir: cache::CACHE_DIR, use_cach
let sample_04_hashes: [u64; 3] = [14620651386429567209,
14620651386429567209,
14620651386429567209];
test_imageset_hash(hash::HashType::DHash, hash::Precision::Medium, sample_04_images, sample_04_hashes);
test_imageset_hash(hash::HashType::DHash,
hash::Precision::Medium,
sample_04_images,
sample_04_hashes);
// Clean_Cache
// super::teardown();
@ -278,10 +315,11 @@ static LIB_CACHE: Cache<'static> = Cache { cache_dir: cache::CACHE_DIR, use_cach
let sample_01_images: [&Path; 3] = [&Path::new("./test_images/sample_01_large.jpg"),
&Path::new("./test_images/sample_01_medium.jpg"),
&Path::new("./test_images/sample_01_small.jpg")];
let sample_01_hashes: [u64; 3] = [72357778504597504,
72357778504597504,
72357778504597504];
test_imageset_hash(hash::HashType::PHash, hash::Precision::Medium, sample_01_images, sample_01_hashes);
let sample_01_hashes: [u64; 3] = [72357778504597504, 72357778504597504, 72357778504597504];
test_imageset_hash(hash::HashType::PHash,
hash::Precision::Medium,
sample_01_images,
sample_01_hashes);
// Sample_02 tests
let sample_02_images: [&Path; 3] = [&Path::new("./test_images/sample_02_large.jpg"),
@ -290,7 +328,10 @@ static LIB_CACHE: Cache<'static> = Cache { cache_dir: cache::CACHE_DIR, use_cach
let sample_02_hashes: [u64; 3] = [5332332327550844928,
5332332327550844928,
5332332327550844928];
test_imageset_hash(hash::HashType::PHash, hash::Precision::Medium, sample_02_images, sample_02_hashes);
test_imageset_hash(hash::HashType::PHash,
hash::Precision::Medium,
sample_02_images,
sample_02_hashes);
// Sample_03 tests
let sample_03_images: [&Path; 3] = [&Path::new("./test_images/sample_03_large.jpg"),
@ -299,7 +340,10 @@ static LIB_CACHE: Cache<'static> = Cache { cache_dir: cache::CACHE_DIR, use_cach
let sample_03_hashes: [u64; 3] = [6917529027641081856,
6917529027641081856,
6917529027641081856];
test_imageset_hash(hash::HashType::PHash, hash::Precision::Medium, sample_03_images, sample_03_hashes);
test_imageset_hash(hash::HashType::PHash,
hash::Precision::Medium,
sample_03_images,
sample_03_hashes);
// Sample_04 tests
let sample_04_images: [&Path; 3] = [&Path::new("./test_images/sample_04_large.jpg"),
@ -308,7 +352,10 @@ static LIB_CACHE: Cache<'static> = Cache { cache_dir: cache::CACHE_DIR, use_cach
let sample_04_hashes: [u64; 3] = [10997931646002397184,
10997931646002397184,
11142046834078253056];
test_imageset_hash(hash::HashType::PHash, hash::Precision::Medium, sample_04_images, sample_04_hashes);
test_imageset_hash(hash::HashType::PHash,
hash::Precision::Medium,
sample_04_images,
sample_04_hashes);
// Clean_Cache
// super::teardown();

3
src/main.rs
View File

@ -69,8 +69,7 @@ fn main() {
hashes.orig_path,
hashes.ahash,
hashes.dhash,
hashes.phash
);
hashes.phash);
println!("{}", hash_result);
}
// Otherwise process only specific hashes

Write Preview
Loading…
Cancel
Save