Q/PhcdZddlmZmZmZddlZddlZddlmZm Z  ej j Z n#e $r ej Z YnwxYwdZ dZGddZ dd lmZed Zn #e$reZYnwxYw ddlZejjejZn#e ef$reZYnwxYwejd krOejd krejd krddlmZnddlmZ eegefZeejgefZn#e $reZeZYnwxYwdZ!dZ"dZ#d'dZ$dej%fdZ&d(dZ'd(dZ(d'dZ)d'dZ*d)dZ+d*dZ,Gdd Z-d!Z.d"Z/ d+d&Z0dS),a Perceptual image hashing library Example: >>> from PIL import Image >>> import imagehash >>> hash = imagehash.average_hash(Image.open('test.png')) >>> print(hash) d879f8f89b1bbf >>> otherhash = imagehash.average_hash(Image.open('other.bmp')) >>> print(otherhash) ffff3720200ffff >>> print(hash == otherhash) False >>> print(hash - otherhash) 36 >>> for r in range(1, 30, 5): ... rothash = imagehash.average_hash(Image.open('test.png').rotate(r)) ... print('Rotation by %d: %d Hamming difference' % (r, hash - rothash)) ... Rotation by 1: 2 Hamming difference Rotation by 6: 11 Hamming difference Rotation by 11: 13 Hamming difference Rotation by 16: 17 Hamming difference Rotation by 21: 19 Hamming difference Rotation by 26: 21 Hamming difference >>> )absolute_importdivisionprint_functionN)Image ImageFilterz4.3.1cddd|zD}ttjt |dz }dt|d|S)zA internal function to make a hex string out of a binary array. c34K|]}t|VdSNstr).0bs R/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/imagehash/__init__.py z'_binary_array_to_hex..Us(88c!ff888888z {:0>{width}x}width)joinflattenintnumpyceillenformat)arr bit_stringrs r_binary_array_to_hexr!Qsvgg88a#++--&788888 UZJ!+ , , - -s:q11???rcBeZdZdZdZdZdZdZdZdZ dZ d Z d S) ImageHashzH Hash encapsulation. Can be used for dictionary keys and comparisons. c||_dSr hash)self binary_arrays r__init__zImageHash.__init___s $)))rcNt|jSr )r!r&rr's r__str__zImageHash.__str__cs di//11 2 22rc*t|jSr )reprr&r+s r__repr__zImageHash.__repr__fs dirc.|td|jj|jjkr%td|jj|jjt j|j|jkS)NzOther hash must not be None.z&ImageHashes must be of the same shape.) TypeErrorr&sizeshaper count_nonzerorr'others r__sub__zImageHash.__sub__isw ] 1 2 22 Y^uz&& ;TY_ejN^ _ __  TY..00EJ4F4F4H4HH I IIrc|dStj|j|jSNFr array_equalr&rr5s r__eq__zImageHash.__eq__qs; ] %  49,,.. 0B0B0D0D E EErc|dStj|j|j Sr9r:r5s r__ne__zImageHash.__ne__ws> ] %  ty0022EJ4F4F4H4H I I IIrc|tdt|jDS)Nc(g|]\}}|d|dzzS)rrivs r z&ImageHash.__hash__..s) I I ITQq Ia!a%j I I Ir)sum enumerater&rr+s r__hash__zImageHash.__hash__}s5 I IYty/@/@/B/B%C%C I I I J JJrc|jjSr )r&r2r+s r__len__zImageHash.__len__s rN) __name__ __module__ __qualname____doc__r)r,r/r7r<r>rIrKrBrrr#r#Zs333JJJFFF JJJ KKKrr#)Literal)haardb4)rS)rS r)rSrTr)Callablechttjt|dzdt|dzfdt dtD}tjd|D}t|S)aE Convert a stored hash (hex, as retrieved from str(Imagehash)) back to a Imagehash object. Notes: 1. This algorithm assumes all hashes are either bidimensional arrays with dimensions hash_size * hash_size, or onedimensional arrays with dimensions binbits * 14. 2. This algorithm does not work for hash_size < 2. r {:0>{width}b}rc*g|]}||zSrBrB)rrDr( hash_sizes rrFzhex_to_hash..s& [ [ [q\!A M/ * [ [ [rrc&g|]}d|DS)cFg|]}tt|SrBboolrrds rrFz*hex_to_hash...s$666QDQLL666rrB)rrows rrFzhex_to_hash..s'KKK366#666KKKr)rrsqrtrrrangearrayr#)hexstrbit_rows hash_arrayr(rZs @@r hex_to_hashrhsCKK!O,, - -&&s62i)>S&TT [ [ [ [ [E!S=N=NPY4Z4Z [ [ [kKK(KKKLL*rc tt|dz|z }dt|d||z}tjd|Dg| |zd}t |S)NrrWrXrcFg|]}tt|SrBr]r_s rrFz#hex_to_flathash..s$???QDQLL???r)rrrrrdr#)rehashsizerZr(rgs rhex_to_flathashrls VqH- . .&&s62i(>R&SSk??,???@AA9*xBWBXBXY*rcb|d}d|D}t|S)a Convert a stored multihash (hex, as retrieved from str(ImageMultiHash)) back to an ImageMultiHash object. This function is based on hex_to_hash so the same caveats apply. Namely: 1. This algorithm assumes all hashes are either bidimensional arrays with dimensions hash_size * hash_size, or onedimensional arrays with dimensions binbits * 14. 2. This algorithm does not work for hash_size < 2. ,c,g|]}t|SrB)rhrxs rrFz$hex_to_multihash..s ) ) )a;q>> ) ) )r)splitImageMultiHash)rerrhashess rhex_to_multihashrus6 c   ) )5 ) ) )vrrAcg}||dzz}t||kr$d}t||t|dzD]V}||dz|dzdz}t d|zd|fdtdDWt tj|S)a  Convert a stored hash (hex, as retrieved from str(Imagehash)) back to a Imagehash object. This method should be used for hashes generated by ImageHash up to version 3.7. For hashes generated by newer versions of ImageHash, hex_to_hash should be used instead. rzExpected hex string size of {}.r0xrXc(g|]}d|zzdkS)rrrBrCs rrFz#old_hex_to_hash..s% - - -qa!Q$hl - - -rrA) r ValueErrorrrcrappendr#rrd)rerZrcountemsgrDhrEs @rold_hex_to_hashr~s  i1n %KK5 *$4;;u%%&&&   //Q QU1q519_! $(B!** - - - -E!HH - - -....%+c""###rc|dkrtd|d||ft}t j|}||}||k}t |S)a Average Hash computation Implementation follows http://www.hackerfactor.com/blog/index.php?/archives/432-Looks-Like-It.html Step by step explanation: https://web.archive.org/web/20171112054354/https://www.safaribooksonline.com/blog/2013/11/26/image-hashing-with-python/ # noqa: E501 @image must be a PIL instance. @mean how to determine the average luminescence. can try numpy.median instead. r,Hash size must be greater than or equal to 2Lryconvertresize ANTIALIASrasarrayr#)imagerZmeanpixelsavgdiffs r average_hashrsyMMABBB s   " "Iy#99 E E -   tF||  $rrc|dkrtdddl}||z}|d||ft}t j|}|j|j|dd}|d|d|f}t j |}||k} t| S) Perceptual Hash computation. Implementation follows http://www.hackerfactor.com/blog/index.php?/archives/432-Looks-Like-It.html @image must be a PIL instance. rrrNr)axisr) ry scipy.fftpackrrrrrfftpackdctmedianr#) rrZhighfreq_factorscipyimg_sizerr dctlowfreqmedrs rphashrsMMABBB  ' s   " "Hh#7 C C -   }**6*::CC*9*jyj() |JS$rcDddl}||z}|d||ft}t j|}|j|}|d|d|dzf}|}||k} t| S)rrNrr) rrrrrrrrrr#) rrZrrrrrrrrs r phash_simplers  ' s   " "Hh#7 C C -   }  *9*a A o-.S$rc|dkrtd|d|dz|ft}t j|}|ddddf|ddddfk}t |S)z Difference Hash computation. following http://www.hackerfactor.com/blog/index.php?/archives/529-Kind-of-Like-That.html computes differences horizontally @image must be a PIL instance. rrrrNrrrZrrs rdhashr/sMMABBB s   " "IM9#=y I I -  qqq!""u qqq#2#v&$rc|d||dzft}tj|}|ddddf|ddddfk}t |S)z Difference Hash computation. following http://www.hackerfactor.com/blog/index.php?/archives/529-Kind-of-Like-That.html computes differences vertically @image must be a PIL instance. rrNr)rrrrrr#rs rdhash_verticalrEss s   " "Iy1}#=y I I -  qrr111u ssAAAv&$rrQTc`ddl}|||dz zdks JdnFdttjt |jz}t ||}ttj|}ttj|}||dz zdks Jd||ks Jd||z } |d||ft}tj |d z } |rM| | d | } t| } | dxxdzcc<| | d } | | || } | d} tj| } | | k}t|S) a Wavelet Hash computation. based on https://www.kaggle.com/c/avito-duplicate-ads-detection/ @image must be a PIL instance. @hash_size must be a power of 2 and less than @image_scale. @image_scale must be power of 2 and less than image size. By default is equal to max power of 2 for an input image. @mode (see modes in pywt library): 'haar' - Haar wavelets, by default 'db4' - Daubechies wavelets @remove_max_haar_ll - remove the lowest low level (LL) frequency using Haar wavelet. rNrzimage_scale is not power of 2rzhash_size is not power of 2zhash_size in a wrong rangergo@rQ)level)pywtrrlog2minr2maxrrrrwavedec2listwaverec2rr#)rrZ image_scalemoderemove_max_haar_llrimage_natural_scale ll_max_levelr dwt_levelrcoeffsdwt_lowrrs rwhashrXs    a (A - - -/N - - - -3uz#ej//::;;;'33+EJ{++,, UZ " " # #Y]#q(((*G((( ; E ! s   " "K#=y I I -   %) ==|= < <& <<&)))q.))) == ( (& --I- 6 6 !9 |G# $rrSc tj|d}d|dD\}}|dk}|}|dk}tj||}tj||} tj| |dk} tj| |dk} td| } tj dd d } | r tj || | \}}n$tj t| dz }| r tj || | \}}n$tj t| dz }d z}t|dz t||zt|dz t||zg}t!|t!|zD]>}|t|dz t||zd z| z ?g}|D]!|fdt%Dz }"t'tj|dfS)a Color Hash computation. Computes fractions of image in intensity, hue and saturation bins: * the first binbits encode the black fraction of the image * the next binbits encode the gray fraction of the remaining image (low saturation) * the next 6*binbits encode the fraction in 6 bins of saturation, for highly saturated parts of the remaining image * the next 6*binbits encode the fraction in 6 bins of saturation, for mildly saturated parts of the remaining image @binbits number of bits to use to encode each pixel fractions rcZg|](}tj|)SrB)rrr)rrEs rrFzcolorhash..s. M M M1EM!   $ $ & & M M MrHSV Urr)binsrg?cFg|]}d|z dz zzd|z zzdkS)rrrrB)rrDbinbitsrEs rrFzcolorhash..s>ZZZaqQ1q)*Q1-==AZZZrr)rrrrrrr logical_andrrGlinspaceany histogramzerosrrrrrzrcr#reshape)rr intensityr}s mask_black frac_black mask_gray frac_gray mask_colorsmask_faint_colorsmask_bright_colorschue_binsh_faint_counts_h_bright_countsmaxvaluevaluescountsbitarrayrEs ` @r colorhashrs ]5==-- . . 6 6 8 8 M M e0D0D0J0J0L0L M M MAq("oo \   {I 6 6 ; ; = = *yj99&{A 4DEE' Q5EFFKOO   N1c5 ) )2oa(9&:JJJ.!!;s8}}q011.3q);'<8LLL/11KH  122/ wJ x!|Sh!677 8 8#hlCPY\dPdLeLe:f:f gN##d?&;&;;DDV--HqL#fx&7"&>ZZZZ((%-))112w-@@AAArcVeZdZdZdZdZdZddZdZdZ d Z dd Z dd Z dd Z dS)rsz This is an image hash containing a list of individual hashes for segments of the image. The matching logic is implemented as described in Efficient Cropping-Resistant Robust Image Hashing c||_dSr )segment_hashes)r'rts rr)zImageMultiHash.__init__s$rc4|dS||Sr9matchesr5s rr<zImageMultiHash.__eq__s ] % e  rc.|| Sr rr5s rr>zImageMultiHash.__ne__s \\%  rNc||||\}}t|j}|dkr|S|t|jdz}dt||z z }||z} || z S)Nr) hash_diffrrfloat) r'r6hamming_cutoffbit_error_rater sum_distancemax_difference max_distance tie_breaker match_scores rr7zImageMultiHash.__sub__s..OO'<t*++. \\ 3t215666,U<((<78++%+ + %%rcXttd|jDS)Nc34K|]}t|VdSr r%)rsegments rrz*ImageMultiHash.__hash__..s(EEgDMMEEEEEEr)r&tuplerr+s rrIzImageMultiHash.__hash__s* eEE1DEEEEE F FFrcJdd|jDS)Nrnc34K|]}t|VdSr r rps rrz)ImageMultiHash.__str__..s(66Q#a&&666666r)rrr+s rr,zImageMultiHash.__str__s& 66$"5666 6 66rc*t|jSr )r.rr+s rr/zImageMultiHash.__repr__s d! " ""rc|!|d}t|jd|z}g}|jD]>tfd|jD}||kr)||?t|t |fS)a Gets the difference between two multi-hashes, as a tuple. The first element of the tuple is the number of matching segments, and the second element is the sum of the hamming distances of matching hashes. NOTE: Do not order directly by this tuple, as higher is better for matches, and worse for hamming cutoff. :param other_hash: The image multi hash to compare against :param hamming_cutoff: The maximum hamming distance to a region hash in the target hash :param bit_error_rate: Percentage of bits which can be incorrect, an alternative to the hamming cutoff. The default of 0.25 means that the segment hashes can be up to 25% different Ng?rc3"K|] }|z V dSr rB)rother_segment_hash segment_hashs rrz+ImageMultiHash.hash_diff..s=%%r)rrrrzrG)r' other_hashrr distanceslowest_distancers @rrzImageMultiHash.hash_diffsN+A.//.@>))%%l(7?&&  O$$$$ YY ''rrcB||||\}}||kS)a Checks whether this hash matches another crop resistant hash, `other_hash`. :param other_hash: The image multi hash to compare against :param region_cutoff: The minimum number of regions which must have a matching hash :param hamming_cutoff: The maximum hamming distance to a region hash in the target hash :param bit_error_rate: Percentage of bits which can be incorrect, an alternative to the hamming cutoff. The default of 0.25 means that the segment hashes can be up to 25% different )r)r'r region_cutoffrrrrs rrzImageMultiHash.matchess(~~j..II*'1 M !!rc4t|fdS)a Returns the hash in a list which is the best match to the current hash :param other_hashes: A list of image multi hashes to compare against :param hamming_cutoff: The maximum hamming distance to a region hash in the target hash :param bit_error_rate: Percentage of bits which can be incorrect, an alternative to the hamming cutoff. Defaults to 0.25 if unset, which means the hash can be 25% different c2|Sr )r7)rrrr's rz+ImageMultiHash.best_match..s$,,z>>RRr)key)r)r' other_hashesrrs` ``r best_matchzImageMultiHash.best_matchs3 RRRRRR   r)NN)rNN)rLrMrNrOr)r<r>r7rIr,r/rrrrBrrrsrss  !!! & & & &GGG777###((((8 " " " "      rrsct}t}tjtj|}t |d}|||} t}|D]6}|\} } | dz | f| dz| f| | dz f| | dzfg} || 7||||snqt}|D]_}||r@||||||J||`|S)aP Finds a region and returns a set of pixel coordinates for it. :param remaining_pixels: A numpy bool array, with True meaning the pixels are remaining to segment :param segmented_pixels: A set of pixel coordinates which have already been assigned to segment. This will be updated with the new pixels added to the returned segment. rTr) setr transposenonzeroraddcopyupdatedifference_update) remaining_pixelssegmented_pixels in_region not_in_regionavailable_pixelsstart new_pixelstry_nextpixelrqy neighbourss r _find_regionr s{UUOEM2B$C$CDD " # # unn UU(e 41aUAJUAJAJAJ :  ??: -}===  uu*eu MM%NN5e56 rcl |j\ ||k}tj|jdt}g}t }|dt D|dt D| fdt D| fdt Dtj||r~tj||}t||}t||kr| ||D]} d|| <tj||~tj |} t| zkrmtj| |}t||}t||kr| ||D]} d|| <t| zkm|S)a Finds all the regions within an image pixel array, and returns a list of the regions. Note: Slightly different segmentations are produced when using pillow version 6 vs. >=7, due to a change in rounding in the greyscale conversion. :param pixels: A numpy array of the pixel brightnesses. :param segment_threshold: The brightness threshold to use when differentiating between hills and valleys. :param min_segment_size: The minimum number of pixels for a segment. T)dtypecg|]}d|fSrrBrzs rrFz&_find_all_segments.._s>>>qB7>>>rcg|]}|dfSrrBrs rrFz&_find_all_segments..`s===qAr7===rcg|]}|fSrBrB)rr img_widths rrFz&_find_all_segments..asEEEaIq>EEErcg|]}|fSrBrB)rr img_heights rrFz&_find_all_segments..bsEEEqAz?EEErF) r3rfullr^rrrc bitwise_andrrrrzinvert) rsegment_thresholdmin_segment_sizethreshold_pixelsunassigned_pixelssegmentsalready_segmentedrrpixthreshold_pixels_irrs @@r_find_all_segmentsr)Lsf J..Z d$??? UU>>E*,=,=>>>???==E),<,<===>>>EEEE53D3DEEEFFFEEEEE)4D4DEEEFFF )+<==AACC"&'79JKK )+< = ='\\$$$ ??7 ""c!S )+<==AACC"l#344  J 666&'9;LMM )+< = ='\\$$$ ??7 ""c!S  J 666 r,c|t}|}|d||ft}|t jt j}tj | tj }t|||}|s!d|dz |dz fh} || |rt|ddd|}g} |D]} |j\} } t#| |z }t#| |z }t%d| D|z}t%d | D|z}t'd | Ddz|z}t'd | Ddz|z}|||||f}| ||t+| S) a Creates a CropResistantHash object, by the algorithm described in the paper "Efficient Cropping-Resistant Robust Image Hashing". DOI 10.1109/ARES.2014.85 This algorithm partitions the image into bright and dark segments, using a watershed-like algorithm, and then does an image hash on each segment. This makes the image much more resistant to cropping than other algorithms, with the paper claiming resistance to up to 50% cropping, while most other algorithms stop at about 5% cropping. Note: Slightly different segmentations are produced when using pillow version 6 vs. >=7, due to a change in rounding in the greyscale conversion. This leads to a slightly different result. :param image: The image to hash :param hash_func: The hashing function to use :param limit_segments: If you have storage requirements, you can limit to hashing only the M largest segments :param segment_threshold: Brightness threshold between hills and valleys. This should be static, putting it between peak and trough dynamically breaks the matching :param min_segment_size: Minimum number of pixels for a hashable segment :param segmentation_image_size: Size which the image is resized to before segmentation Nr)rrrc t|Sr )r)rs rrz%crop_resistant_hash..s CFFrT)rreversec3&K|] }|dV dSrNrBrcoords rrz&crop_resistant_hash..& , ,5eAh , , , , , ,rc3&K|] }|dV dSrNrBr2s rrz&crop_resistant_hash..r4rc3&K|] }|dV dSr1rBr2s rrz&crop_resistant_hash..&--EuQx------rc3&K|] }|dV dSr6rBr2s rrz&crop_resistant_hash..r8r)rrrrrfilterr GaussianBlur MedianFilterrrdastypefloat32r)rzsortedr2rrrcroprs)r hash_funclimit_segmentsr!r"segmentation_image_size orig_imagerr%full_image_segmentrtrorig_worig_hscale_wscale_hmin_ymin_xmax_ymax_x bounding_boxs rcrop_resistant_hashrO|s(4)jjll s   " "$;=T#UW` a a k.00 1 1 8 89Q9S9S T T +e   # #EM 2 2 v'8:J K K &!81!<>UXY>Y Z[ //$%%%S H"2"2D A A A/>/ R(  ) )W?.&& &MM3 3' &MM3 3' , ,G , , , , ,w 6% , ,G , , , , ,w 6% --W--- - - 1W <% --W--- - - 1W <%%u!=>>,-- ,''(((( vr)rA)rAr)rANrQT)rS)NNr*r+r,)1rO __future__rrrsysrPILrr ResamplingLANCZOSrAttributeError __version__r!r#typingrP WhashMode ImportErrorr numpy.typingNDArraybool_r version_inforUcollections.abcrMeanFuncHashFuncr1rhrlrur~rrrrrrrrrsrr)rOrBrrrasx<A@@@@@@@@@ """"""""   %_   F@@@))))))))Z ] #  <  , $ v !!c&6)&C&C&&&&&& wi& '( u{mY. /(( ( ((( ($$$$$*#$%*8.(,&////d3B3B3B3Bl]]]]]]]]@)))X---d  CCCCCCsB + ::A A*)A*.B BBC$$ C0/C0