/// <inheritdoc />
public ImageDifferenceHash64 Compute(Stream stream, IImageTransformer transformer)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (transformer == null)
{
throw new ArgumentNullException(nameof(transformer));
}
var pixels = transformer.ConvertToGreyscaleAndResize(stream, 9, 8);
var hash = 0UL;
var pos = 0;
for (var y = 0; y < 8; y++)
{
var row = y * 9;
for (var x = 0; x < 8; x++)
{
if (pixels[row + x] > pixels[row + x + 1])
{
hash |= (1UL << pos);
}
pos++;
}
}
return(new ImageDifferenceHash64(hash));
}
/// <summary>
/// Calculates a 64 bit hash for the given image using median algorithm.
///
/// Works by converting the image to 8x8 greyscale image, finding the median pixel value from it, and then marking
/// all pixels where value is greater than median value as 1 in the resulting hash. Should be more resistant to non-linear
/// image edits when compared against average based implementation.
/// </summary>
/// <param name="sourceStream">Stream containing an image to be hashed.</param>
/// <returns>64 bit median hash of the input image.</returns>
internal static ulong Calculate(Stream sourceStream, IImageTransformer _transformer)
{
byte[] pixels = _transformer.TransformImage(sourceStream, 8, 8);
// Calculate median
List <byte> pixelList = new List <byte>(pixels);
pixelList.Sort();
// Even amount of pixels
byte median = (byte)((pixelList[31] + pixelList[32]) / 2);
// Iterate pixels and set them to 1 if over median and 0 if lower.
ulong hash = 0UL;
for (int i = 0; i < 64; i++)
{
if (pixels[i] > median)
{
hash |= 1UL << i;
}
}
// Done
return(hash);
}
/// <summary>
/// Calculates a 256 bit hash for the given image using median algorithm.
///
/// Works by converting the image to 16x16 greyscale image, finding the median pixel value from it, and then marking
/// all pixels where value is greater than median value as 1 in the resulting hash. Should be more resistant to non-linear
/// image edits when compared agains average based implementation.
/// </summary>
/// <param name="sourceStream">Stream containing an image to be hashed.</param>
/// <returns>256 bit median hash of the input image. Composed of 4 ulongs.</returns>
internal static ulong[] Calculate(Stream sourceStream, IImageTransformer _transformer)
{
byte[] pixels = _transformer.TransformImage(sourceStream, 16, 16);
// Calculate median
List <byte> pixelList = new List <byte>(pixels);
pixelList.Sort();
// Even amount of pixels
byte median = (byte)((pixelList[127] + pixelList[128]) / 2);
// Iterate pixels and set them to 1 if over median and 0 if lower.
ulong hash64 = 0UL;
ulong[] hash = new ulong[4];
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 64; j++)
{
if (pixels[(64 * i) + j] > median)
{
hash64 |= 1UL << j;
}
}
hash[i] = hash64;
hash64 = 0UL;
}
// Done
return(hash);
}
//[CompilerGenerated]
//private static Comparison<ThumbnailRecord> <>9__CachedAnonymousMethodDelegate1;
public SourceMapRecord(Layer layer, SourceMap sourceMap, MapTileSourceFactory mapTileSourceFactory)
{
displayName = sourceMap.displayName;
sourceMapInfo = sourceMap.sourceMapInfo;
userBoundingRect = sourceMap.GetUserBoundingBox(mapTileSourceFactory);
maxZoom = sourceMap.sourceMapRenderOptions.maxZoom;
try
{
imageTransformer =
sourceMap.registration.warpStyle.getImageTransformer(sourceMap.registration,
InterpolationMode.Invalid);
}
catch (Exception)
{
}
foreach (Legend current in sourceMap.legendList)
{
legendRecords.Add(new LegendRecord("legends",
sourceMap.GetLegendFilename(current),
current.displayName,
current.GetOutputSizeSynchronously(mapTileSourceFactory.CreateDisplayableUnwarpedSource(sourceMap)
.GetUserBounds(current.latentRegionHolder, FutureFeatures.Cached))));
}
sourceMapLegendFrame = new SourceMapLegendFrame(layer,
sourceMap,
legendRecords,
thumbnailForLegendFrame);
}
/// <inheritdoc />
public ImageAverageHash Compute(Stream stream, IImageTransformer transformer)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (transformer == null)
{
throw new ArgumentNullException(nameof(transformer));
}
var pixels = transformer.ConvertToGreyscaleAndResize(stream, 8, 8);
var total = pixels.Sum(pixel => pixel);
var average = total / 64;
var hash = 0UL;
for (var i = 0; i < 64; i++)
{
if (pixels[i] > average)
{
hash |= (1UL << i);
}
}
return(new ImageAverageHash(hash));
}
private static void Transform(IImageTransformer imageTransformer, string url)
{
for (int i = 0; i < 100; i++)
{
//Console.WriteLine(i);
imageTransformer.Transform(url);
}
}
public AddImageThumbnailCommandHandler(
AzureStorageRepository repository,
IOptions <AzureMediaStorageOptions> storageConfig,
IImageTransformer imageTransofrmer)
{
_repository = repository ?? throw new ArgumentNullException(nameof(repository));
_storageConfig = storageConfig ?? throw new ArgumentNullException(nameof(storageConfig));
_imageTransofrmer = imageTransofrmer ?? throw new ArgumentNullException(nameof(imageTransofrmer));
}
public ImageService(
ITransformedImageCache imageCacheHandler,
IOriginalImageBlobStorage originalImageStorage,
IImageTransformer imageTransformer,
ILogger <ImageService> logger)
{
this.imageCacheHandler = imageCacheHandler;
this.originalImageStorage = originalImageStorage;
this.imageTransformer = imageTransformer;
this.logger = logger;
}
public ImageService(IImageTransformer imageResizer, IFileSystemService imageinfoProvider, IPhotoService photoService, IDynamicConfig dynamicConfig,
IBackgroundTaskQueue queue, ILogger <ImageService> logger, IImageMetadataService metadataService)
{
_imageTransformer = imageResizer;
_fileSystemService = imageinfoProvider;
_photoService = photoService;
_dynamicConfig = dynamicConfig;
_queue = queue;
_logger = logger;
_metadataService = metadataService;
}
public ImageSharpImageProccessor(
IImageTransformer imageTransformer,
IOptions <ImageSharpImageProccessorOptions> options,
ILogger <ImageSharpImageProccessor> logger)
{
_imageTransformer = imageTransformer ?? throw new ArgumentNullException(nameof(imageTransformer));
_options = options.Value ?? throw new ArgumentNullException(nameof(options));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_configuration = Configuration.Default;
}
/// <summary>
/// Calculates a hash for the given image using dct algorithm
/// </summary>
/// <param name="sourceStream">Stream to the image used for hash calculation.</param>
/// <returns>64 bit difference hash of the input image.</returns>
internal ulong Calculate(Stream sourceStream, IImageTransformer _transformer)
{
lock (_dctMatrixLockObject) {
if (!_isDctMatrixInitialized)
{
_dctMatrix = GenerateDctMatrix(32);
_isDctMatrixInitialized = true;
}
}
byte[] pixels = _transformer.TransformImage(sourceStream, 32, 32);
// Copy pixel data and convert to float
float[] fPixels = new float[1024];
for (int i = 0; i < 1024; i++)
{
fPixels[i] = pixels[i] / 255.0f;
}
// Calculate dct
float[][] dctPixels = ComputeDct(fPixels, _dctMatrix);
// Get 8*8 area from 1,1 to 8,8, ignoring lowest frequencies for improved detection
float[] dctHashPixels = new float[64];
for (int x = 0; x < 8; x++)
{
for (int y = 0; y < 8; y++)
{
dctHashPixels[x + (y * 8)] = dctPixels[x + 1][y + 1];
}
}
// Calculate median
List <float> pixelList = new List <float>(dctHashPixels);
pixelList.Sort();
// Even amount of pixels
float median = (pixelList[31] + pixelList[32]) / 2;
// Iterate pixels and set them to 1 if over median and 0 if lower.
ulong hash = 0UL;
for (int i = 0; i < 64; i++)
{
if (dctHashPixels[i] > median)
{
hash |= 1UL << i;
}
}
// Done
return(hash);
}
/// <inheritdoc />
public ImageDifferenceHash256 Compute(Stream stream, IImageTransformer transformer)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (transformer == null)
{
throw new ArgumentNullException(nameof(transformer));
}
var pixels = transformer.ConvertToGreyscaleAndResize(stream, 17, 16);
var hash = new ulong[4];
var pos = 0;
var part = 0;
for (var y = 0; y < 16; y++)
{
var row = y * 17;
for (var x = 0; x < 16; x++)
{
if (pixels[row + x] > pixels[row + x + 1])
{
hash[part] |= (1UL << pos);
}
if (pos == 63)
{
pos = 0;
part++;
}
else
{
pos++;
}
}
}
return(new ImageDifferenceHash256(hash));
}
/// <summary>
/// Calculates a 64 bit hash for the given image using average algorithm.
/// </summary>
/// <param name="sourceStream">Stream containing an image to be hashed.</param>
/// <returns>64 bit average hash of the input image.</returns>
internal static ulong Calculate(Stream sourceStream, IImageTransformer _transformer)
{
byte[] pixels = _transformer.TransformImage(sourceStream, 8, 8);
// Calculate average
List <byte> pixelList = new List <byte>(pixels);
int total = pixelList.Aggregate(0, (current, pixel) => current + pixel);
int average = total / 64;
// Iterate pixels and set them to 1 if over average and 0 if lower.
ulong hash = 0UL;
for (int i = 0; i < 64; i++)
{
if (pixels[i] > average)
{
hash |= 1UL << i;
}
}
// Done
return(hash);
}
/// <summary>
/// Calculates 64 bit hash for the given image using difference hash.
///
/// See http://www.hackerfactor.com/blog/index.php?/archives/529-Kind-of-Like-That.html for algorithm description.
/// </summary>
/// <param name="sourceStream">Stream containing an image to be hashed.</param>
/// <returns>64 bit difference hash of the input image.</returns>
internal static ulong Calculate(Stream sourceStream, IImageTransformer _transformer)
{
byte[] pixels = _transformer.TransformImage(sourceStream, 9, 8);
// Iterate pixels and set hash to 1 if the left pixel is brighter than the right pixel.
ulong hash = 0UL;
int hashPos = 0;
for (int i = 0; i < 8; i++)
{
int rowStart = i * 9;
for (int j = 0; j < 8; j++)
{
if (pixels[rowStart + j] > pixels[rowStart + j + 1])
{
hash |= 1UL << hashPos;
}
hashPos++;
}
}
// Done
return(hash);
}
public ImagesLibrary(IImagesCache imagesCache, IImageLoader imageLoader, IImageTransformer imageTransformer)
{
_imagesCache = imagesCache;
_imageLoader = imageLoader;
_imageTransformer = imageTransformer;
}
/// <summary>
/// Initializes a new <see cref="ImageHasher"/>.
/// </summary>
/// <param name="transformer">Implementation of the image conversion methods.</param>
/// <exception cref="ArgumentNullException">
/// The <paramref name="transformer"/> parameter is null.
/// </exception>
public ImageHasher(IImageTransformer transformer)
{
Transformer = transformer ?? throw new ArgumentNullException(nameof(transformer));
}
/// <summary>
/// Resizes the current image to the given dimensions.
/// </summary>
/// <param name="size">
/// The <see cref="T:System.Drawing.Size"/> containing the width and height to set the image to.
/// </param>
/// <returns>
public static IImageTransformer Resize(this IImageTransformer transformer, Size size)
{
return(transformer.Resize(new ResizeOptions {
Size = size
}));
}
/// <summary>
/// Initializes a new instance of the ImageHashes class using ImageMagickTransformer.
/// </summary>
public ImageHashes()
{
_transformer = new ImageMagickTransformer();
}
/// <summary> /// Initializes a new instance of the ImageHashes class using the given IImageTransformer. /// </summary> /// <param name="transformer">Implementation of the IImageTransformer to be used for image transformation.</param> public ImageHashes(IImageTransformer transformer) => _transformer = transformer;
public ImagesController(IImageStore imageStore, IImageTransformer imageTransformer)
{
_imageStore = imageStore;
_imageTransformer = imageTransformer;
}
