using System;

using System. Collections. Generic;

using System. Linq;

using System. Threading. Tasks;

using ImageSuperResolution. SRCNN. Handler. Messages;

namespace ImageSuperResolution. SRCNN. Handler. Upscalling

{

public class SRCNNHandler

{

public SRCNNModelLayer [] ScaleModel { get; set; }

public int Scale { get; set; } = 2;

private ImagePlane Normalize (ImageChannel image)

{

int width = image. Width;

int height = image. Height;

ImagePlane imagePlane = new ImagePlane (width, height);

if (imagePlane. Buffer. Length! = image. Buffer. Length)

{

throw new Exception ("Assertion error: length");

}

for (int i = 0; i < image. Buffer. Length; i++)

{

double temp = image. Buffer [i] / 255.0;

imagePlane. Buffer [i] = temp;

}

return imagePlane;

}

private ImageChannel Denormalize (ImagePlane imagePlane)

{

ImageChannel image = new ImageChannel (imagePlane. Width, imagePlane. Height);

for (int i = 0; i < imagePlane. Buffer. Length; i++)

{

double temp = Math. Round (imagePlane. Buffer [i] * 255, MidpointRounding. AwayFromZero);

image. Buffer [i] = temp > 255? (byte) 255: (byte) temp;

}

return image;

}

private ImagePlane [] Convolution (ImagePlane [] inputPlanes, double [] W, int nOutputPlane, double [] bias)

{

int width = inputPlanes [0]. Width;

int height = inputPlanes [0]. Height;

ImagePlane [] outputPlanes = new ImagePlane [nOutputPlane];

for (int o = 0; o < nOutputPlane; o++)

{

outputPlanes [o] = new ImagePlane (width - 2, height - 2);

}

double [] sumValues = new double [nOutputPlane];

double [] biasValues = new double [nOutputPlane];

bias. CopyTo (biasValues, 0);

for (int w = 1; w < width - 1; w++)

{

for (int h = 1; h < height - 1; h++)

{

biasValues. CopyTo (sumValues, 0); // leaky ReLU bias

for (int i = 0; i < inputPlanes. Length; i++)

{

double i00 = inputPlanes [i]. GetValue (w - 1, h - 1);

double i10 = inputPlanes [i]. GetValue (w, h - 1);

double i20 = inputPlanes [i]. GetValue (w + 1, h - 1);

double i01 = inputPlanes [i]. GetValue (w - 1, h);

double i11 = inputPlanes [i]. GetValue (w, h);

double i21 = inputPlanes [i]. GetValue (w + 1, h);

double i02 = inputPlanes [i]. GetValue (w - 1, h + 1);

double i12 = inputPlanes [i]. GetValue (w, h + 1);

double i22 = inputPlanes [i]. GetValue (w + 1, h + 1);

for (int o = 0; o < nOutputPlane; o++)

{

int weightIndex = (o * inputPlanes. Length * 9) + (i * 9);

double value = sumValues [o];

value += i00 * W [weightIndex++];

value += i10 * W [weightIndex++];

value += i20 * W [weightIndex++];

value += i01 * W [weightIndex++];

value += i11 * W [weightIndex++];

value += i21 * W [weightIndex++];

value += i02 * W [weightIndex++];

value += i12 * W [weightIndex++];

value += i22 * W [weightIndex++];

sumValues [o] = value;

}

}

for (int o = 0; o < nOutputPlane; o++)

{

double v = sumValues [o];

if (v < 0)

{

v *= 0.1;

}

outputPlanes [o]. SetValue (w - 1, h - 1, v);

}

}

}

return outputPlanes;

}

private double [] [] GetWeights (SRCNNModelLayer [] model)

{

LinkedList<double [] > arrayW = new LinkedList<double [] > ();

foreach (SRCNNModelLayer layer in model)

{

arrayW. AddLast (layer. GetAllWeights ());

}

return arrayW. ToArray ();

}

private ImagePlane [] [] UpscaleBlocks (SRCNNModelLayer [] model, double [] [] weights, Action<ProgressMessage> progressCallback, int blockGroup, int totalBlockGroups, params ImagePlane [] [] blocks)

{

List<ImagePlane [] > outputBlocks = new List<ImagePlane [] > ();

for (int b = 0; b < blocks. Length; b++)

{

ImagePlane [] inputBlock = blocks [b];

ImagePlane [] outputBlock = null;

for (int l = 0; l < model. Length; l++)

{

int nOutputPlane = model [l]. OutputPlanesCount;

// convolution

outputBlock = Convolution (inputBlock, weights [l], nOutputPlane, model [l]. Bias);

inputBlock = outputBlock; // propagate output plane to next layer input

// imageBlocks. Blocks [b] = null;

}

outputBlocks. Add (outputBlock);

int doneRatio = (int) Math. Round ( (double) (100 * (b + 1)) / blocks. Length, MidpointRounding. AwayFromZero);

progressCallback (new BlockUpscalling (blockGroup, totalBlockGroups)

{

Percent = doneRatio

});

}

// imageBlocks. Blocks = null;

return outputBlocks. ToArray ();

}

private ImageChannels UpscaleRgbAsync (ImageChannels channels, SRCNNModelLayer [] model, int scale, Action<ProgressMessage> progressCallback, string phase)

{

ImagePlane [] inputPlanes = channels. ToArray (). Select ( (image) =>

{

ImageChannel imgResized = scale == 1? image: image. Resize (scale);

// extrapolation for layer count (each convolution removes outer 1 pixel border)

ImageChannel imgExtra = imgResized. Extrapolation (model. Length);

return Normalize (imgExtra);

}). ToArray ();

// blocking

ImageBlocks imageBlocks = ImagePlane. Blocking (inputPlanes);

inputPlanes = null;

// init W

double [] [] weights = GetWeights (model);

var outputBlocks = imageBlocks. Blocks. AsParallel ()

. SelectMany ( (block, index) => UpscaleBlocks (model, weights, progressCallback,

index + 1, imageBlocks. Blocks. Count,

block))

. ToList ();

// de-blocking

ImagePlane [] outputPlanes = ImagePlane. Deblocking (outputBlocks. ToArray (), imageBlocks. BlocksWidth, imageBlocks. BlocksHeight);

if (outputPlanes. Length! = 3)

{

throw new Exception ("Output planes must be 3: color channel R, G, B. ");

}

ImageChannels outputChannels = new ImageChannels ()

{

Red = Denormalize (outputPlanes [0]),

Green = Denormalize (outputPlanes [1]),

Blue = Denormalize (outputPlanes [2]),

Alpha = channels. Alpha

};

return outputChannels;

}

public async Task UpscaleImage (byte [] image, int width, int height, Action<ResultMessage> done, Action<ProgressMessage> progress)

{

TimeSpan timeSpanStart = TimeSpan. FromTicks (DateTime. Now. Ticks);

// decompose

progress (new ProgressMessage (UpscallingStatuses. Decompose, "in process"));

ImageChannels channels = ImageChannel. ChannelDecompose (image, width, height);

progress (new ProgressMessage (UpscallingStatuses. Decompose, "ready"));

// calculate

// Scaling all blocks

ImageChannels upscaledChannels = await Task.run ( () => UpscaleRgbAsync (channels, ScaleModel, Scale, progress, "scale"));

// Scaled all blocks

// resize alpha channel

ImageChannel imageA = Scale == 1? upscaledChannels. Alpha: upscaledChannels. Alpha. Resize (Scale);

if (imageA. Buffer. Length! = upscaledChannels. Red. Buffer. Length)

{

throw new Exception ("A channel image size must be same with R channel image size");

}

upscaledChannels. Alpha = imageA;

// recompose

progress (new ProgressMessage (UpscallingStatuses.compose, "in process"));

byte [] upscaledImage = ImageChannel. ChannelCompose (upscaledChannels);

progress (new ProgressMessage (UpscallingStatuses.compose, "ready"));

TimeSpan elapsedTime = TimeSpan. FromTicks (DateTime. Now. Ticks) - timeSpanStart;

done (new ResultMessage (upscaledImage, upscaledChannels. Red. Width, upscaledChannels. Red. Height, elapsedTime));

}

public async void UpscaleImageAsync (byte [] image, int width, int height, Action<ResultMessage> done, Action<ProgressMessage> progress)

{

await UpscaleImage (image, width, height, done, progress);

}

}

}

using System;

using System. Collections. Generic;

using System. Linq;

using System. Threading. Tasks;

namespace ImageSuperResolution. SRCNN. Handler. Upscalling

{

public class ImageBlocks

{

public List<ImagePlane [] > Blocks { get; set; }

public int BlocksWidth { get; set; }

public int BlocksHeight { get; set; }

public ImageBlocks ()

{

Blocks = new List<ImagePlane [] > ();

}

}

}

using System;

using System. Collections. Generic;

using System. Linq;

using System. Threading. Tasks;

namespace ImageSuperResolution. SRCNN. Handler. Upscalling

{

public class ImageChannel

{

public int Width { get; set; }

public int Height { get; set; }

public byte [] Buffer { get; set; }

public ImageChannel (int width, int height, byte [] buffer = null)

{

Width = width;

Height = height;

if (buffer! = null)

{

if (buffer. Length! = width * height)

{

throw new ArgumentException ("Illegal buffer length");

}

else

{

Buffer = buffer;

}

}

else

{

Buffer = new byte [width * height];

}

}

public static byte [] ChannelCompose (ImageChannels channels)

{

int width = channels. Red. Width;

int height = channels. Red. Height;

byte [] image = new byte [width * height * 4];

for (int i = 0; i < width * height; i++)

{

image [i * 4] = channels. Red. Buffer [i];

image [i * 4 + 1] = channels. Green. Buffer [i];

image [i * 4 + 2] = channels. Blue. Buffer [i];

image [i * 4 + 3] = channels. Alpha. Buffer [i];

}

return image;

}

public static ImageChannels ChannelDecompose (byte [] image, int width, int height)

{

ImageChannel imageR = new ImageChannel (width, height);

ImageChannel imageG = new ImageChannel (width, height);

ImageChannel imageB = new ImageChannel (width, height);

ImageChannel imageA = new ImageChannel (width, height);

for (int w = 0; w < width; w++)

{

for (int h = 0; h < height; h++)

{

int index = w + (h * width);

imageR. Buffer [index] = image [ (w * 4) + (h * width * 4)];

imageG. Buffer [index] = image [ (w * 4) + (h * width * 4) + 1];

imageB. Buffer [index] = image [ (w * 4) + (h * width * 4) + 2];

imageA. Buffer [index] = image [ (w * 4) + (h * width * 4) + 3];

}

}

return new ImageChannels ()

{

Alpha = imageA,

Red = imageR,

Green = imageG,

Blue = imageB

};

}

public byte [] ChannelDecompose (ImageChannels channels)

{

int width = channels. Red. Width;

int height = channels. Red. Height;

byte [] image = new byte [width * height * 4];

for (int i = 0; i < width * height; i++)

{

image [i * 4] = channels. Red. Buffer [i];

image [i * 4 + 1] = channels. Green. Buffer [i];

image [i * 4 + 2] = channels. Blue. Buffer [i];

image [i * 4 + 3] = channels. Alpha. Buffer [i];

}

return image;

}

private int ToIndex (int widthPosition, int heigthPosition, int width)

{

return widthPosition + heigthPosition * width;

}

public ImageChannel Extrapolation (int px)

{

int width = Width;

int height = Height;

ImageChannel extrapolatedImage = new ImageChannel (width + (2 * px), height + (2 * px));

for (int h = 0; h < height + (px * 2); h++)

{

for (int w = 0; w < width + (px * 2); w++)

{

int index = w + h * (width + (px * 2));

if (w < px)

{

// Left outer area

if (h < px)

{

// Left upper area

extrapolatedImage. Buffer [index] = Buffer [ToIndex (0, 0, width)];

}

else if (px + height <= h)

{

// Left lower area

extrapolatedImage. Buffer [index] = Buffer [ToIndex (0, height - 1, width)];

}

else

{

// Left outer area

extrapolatedImage. Buffer [index] = Buffer [ToIndex (0, h - px, width)];

}

}

else if (px + width <= w)

{

// Right outer area

if (h < px)

{

// Right upper area

extrapolatedImage. Buffer [index] = Buffer [ToIndex (width - 1, 0, width)];

}

else if (px + height <= h)

{

// Right lower area

extrapolatedImage. Buffer [index] = Buffer [ToIndex (width - 1, height - 1, width)];

}

else

{

// Right outer area

extrapolatedImage. Buffer [index] = Buffer [ToIndex (width - 1, h - px, width)];

}

}

else if (h < px)

{

// Upper outer area

extrapolatedImage. Buffer [index] = Buffer [ToIndex (w - px, 0, width)];

}

else if (px + height <= h)

{

// Lower outer area

extrapolatedImage. Buffer [index] = Buffer [ToIndex (w - px, height - 1, width)];

}

else

{

// Inner area

extrapolatedImage. Buffer [index] = Buffer [ToIndex (w - px, h - px, width)];

}

}

}

return extrapolatedImage;

}

public ImageChannel Resize (double scale)

{

int width = Width;

int height = Height;

int scaledWidth = (int) Math. Round (width * scale, MidpointRounding. AwayFromZero);

int scaledHeight = (int) Math. Round (height * scale, MidpointRounding. AwayFromZero);

ImageChannel scaledImage = new ImageChannel (scaledWidth, scaledHeight);

for (int w = 0; w < scaledWidth; w++)

{

for (int h = 0; h < scaledHeight; h++)

{

int scaledIndex = w + (h * scaledWidth);

int originalWidth = (int) Math. Round ( (w + 1) / scale, MidpointRounding. AwayFromZero) - 1;

int originalHeight = (int) Math. Round ( (h + 1) / scale, MidpointRounding. AwayFromZero) - 1;

int originalImageIndex = originalWidth + (originalHeight * width);

scaledImage. Buffer [scaledIndex] = Buffer [originalImageIndex];

}

}

return scaledImage;

}

}

}

using System;

using System. Collections. Generic;

using System. Linq;

using System. Threading. Tasks;

namespace ImageSuperResolution. SRCNN. Handler. Upscalling

{

public class ImageChannels

{

public ImageChannel Alpha { get; set; }

public ImageChannel Red { get; set; }

public ImageChannel Green { get; set; }

public ImageChannel Blue { get; set; }

public ImageChannel [] ToArray (bool ignoreAlpha = true)

{

if (ignoreAlpha)

{

return new ImageChannel [] { Red, Green, Blue };

}

else

{

return new ImageChannel [] { Red, Green, Blue, Alpha};

}

}

}

}

using System;

using System. Collections. Generic;

using System. Linq;

using System. Threading. Tasks;

namespace ImageSuperResolution. SRCNN. Handler. Upscalling

{

public class ImagePlane

{

// Settings

private const int BlockSize = 128;

private const int Overlap = 14;

// Props

public int Width { get; set; }

public int Height { get; set; }

public double [] Buffer { get; private set; }

public ImagePlane (int width, int height, double [] buffer = null)

{

Width = width;

Height = height;

if (buffer! = null)

{

if (buffer. Length! = width * height)

{

throw new ArgumentException ("Illegal buffer length");

}

else

{

Buffer = buffer;

}

}

else

{

Buffer = new double [width * height];

}

}

public long GetIndex (int widthPosition, int heightPosition)

{

return widthPosition + heightPosition * Width;

}

public double GetValue (int widthPosition, int heightPosition)

{

return Buffer [GetIndex (widthPosition, heightPosition)];

}

public void SetValue (int widthPosition, int heightPosition, double value)

{

Buffer [GetIndex (widthPosition, heightPosition)] = value;

}

public static ImageBlocks Blocking (ImagePlane [] initialPlanes)

{

int widthInput = initialPlanes [0]. Width;

int heightInput = initialPlanes [0]. Height;

int blocksWidth = (int) Math. Ceiling ( (double) (widthInput - Overlap) / (BlockSize - Overlap));

int blocksHeight = (int) Math. Ceiling ( (double) (heightInput - Overlap) / (BlockSize - Overlap));

int blocks = blocksWidth * blocksHeight;

ImageBlocks inputBlocks = new ImageBlocks () // [[block0_R, block0_G, block0_B], [block1_R,.].]

{

BlocksWidth = blocksWidth,

BlocksHeight = blocksHeight

};

for (int b = 0; b < blocks; b++)

{

int blockWidthIndex = b % blocksWidth;

int blockHeightIndex = (int) Math. Floor ( (double) (b / blocksWidth));

int blockWidth;

int blockHeight;

if (blockWidthIndex == blocksWidth - 1)

{

blockWidth = widthInput - ( (BlockSize - Overlap) * blockWidthIndex); // right end block

}

else

{

blockWidth = BlockSize;

}

if (blockHeightIndex == blocksHeight - 1)

{

blockHeight = heightInput - ( (BlockSize - Overlap) * blockHeightIndex); // bottom end block

}

else

{

blockHeight = BlockSize;

}

ImagePlane [] channels = new ImagePlane [initialPlanes. Length];

for (int i = 0; i < channels. Length; i++)

{

channels [i] = new ImagePlane (blockWidth, blockHeight);

}

for (int w = 0; w < blockWidth; w++)

{

for (int h = 0; h < blockHeight; h++)

{

for (int n = 0; n < initialPlanes. Length; n++)

{

int targetIndexW = blockWidthIndex * (BlockSize - Overlap) + w;

int targetIndexH = blockHeightIndex * (BlockSize - Overlap) + h;

ImagePlane channel = initialPlanes [n];

double channelValue = channel. GetValue (targetIndexW, targetIndexH);

channels [n]. SetValue (w, h, channelValue);

}

}

}

inputBlocks. Blocks. Add (channels);

}

return inputBlocks;

}

public static ImagePlane [] Deblocking (ImagePlane [] [] outputBlocks, int blocksWidth, int blocksHeight)

{

int blockSize = outputBlocks [0] [0]. Width;

int width = 0;

for (int b = 0; b < blocksWidth; b++)

{

width += outputBlocks [b] [0]. Width;

}

int height = 0;

for (int b = 0; b < blocksWidth * blocksHeight; b += blocksWidth)

{

height += outputBlocks [b] [0]. Height;

}

// console. log ("result image width: " + width + " height: " + height);

List<ImagePlane> outputPlanes = new List<ImagePlane> (); // [planeR, planeG, planeB]

for (int b = 0; b < outputBlocks. Length; b++)

{

ImagePlane [] block = outputBlocks [b];

int blockWidthIndex = b % blocksWidth;

int blockHeightIndex = (int) Math. Floor ( (double) b / blocksWidth);

for (int n = 0; n < block. Length; n++)

{

if (outputPlanes. Count < n + 1)

{

outputPlanes. Add (new ImagePlane (width, height));

}

else if (outputPlanes [n] == null)

{

outputPlanes [n] = new ImagePlane (width, height);

}

ImagePlane channelBlock = block [n];

for (int w = 0; w < channelBlock. Width; w++)

{

for (int h = 0; h < channelBlock. Height; h++)

{

int targetIndexW = blockWidthIndex * blockSize + w;

int targetIndexH = blockHeightIndex * blockSize + h;

int targetIndex = targetIndexH * width + targetIndexW;

double channelValue = channelBlock. GetValue (w, h);

outputPlanes [n]. Buffer [targetIndex] = channelValue;

}

}

}

}

return outputPlanes. ToArray ();

}

}

}

using System;

using System. Collections. Generic;

using System. IO;

using System. Linq;

using System. Threading. Tasks;

using Newtonsoft. Json;

using Newtonsoft. Json. Linq;

namespace ImageSuperResolution. SRCNN. Handler. Upscalling

{

public class SRCNNModelLayer

{

public class ModelConfig

{

public string ModelName { get; set; }

public int ScaleFactor { get; set; }

public int Channels { get; set; }

public int Offset { get; set; }

}

[JsonProperty ("weight")]

public double [] [] [] [] Weights { get; internal set; }

public int StrideHeight { get; set; }

public int StrideWidth { get; set; }

[JsonProperty ("nInputPlane")]

public int InputPlanesCount { get; set; }

[JsonProperty ("nOutputPlane")]

public int OutputPlanesCount { get; set; }

public int KernelWidth { get; set; }

public int KernelHeight { get; set; }

public ModelConfig ModelInfo { get; set; }

[JsonProperty ("bias")]

public double [] Bias { get; set; }

public SRCNNModelLayer ()

{

}

public double [] GetAllWeights ()

{

LinkedList<double> allWeights = new LinkedList<double> ();

foreach (double [] [] [] weightForOutputPlane in Weights)

{

foreach (double [] [] weightMatrix in weightForOutputPlane)

{

foreach (double [] weightVector in weightMatrix)

{

foreach (double omgForGodsSakeFinalWeight in weightVector)

{

allWeights. AddLast (omgForGodsSakeFinalWeight);

}

}

}

}

return allWeights. ToArray ();

}

public static SRCNNModelLayer [] ReadModel (string json)

{

JArray jsonModel = JArray. Parse (json);

List<SRCNNModelLayer> layers = new List<SRCNNModelLayer> ();

foreach (JToken jsonLayer in jsonModel)

{

var layer = JsonConvert. DeserializeObject<SRCNNModelLayer> (jsonLayer. ToString ());

layers. Add (layer);

}

return layers. ToArray ();

}

}

}

using System;

using System. Collections. Generic;

using System. Drawing;

using System. IO;

using System. Threading;

using System. Threading. Tasks;

using ImageSuperResolution. SRCNN. Handler. Messages;

using ImageSuperResolution. SRCNN. Handler. Upscalling;

using RabbitMQ. Client;

using RabbitMQ. Client. Events;

namespace ImageSuperResolution. SRCNN. Handler. Services

{

public class QueueHandler: UpscallingServiceBase

{

private readonly string _queueInput;

private readonly string _queueOutput;

private string _imageConsumerTag;

private IConnection _connectionToMQ;

private IModel _channelInput;

private IModel _channelOutput;

private readonly List<Task> _imagePrecessingTasks;

private readonly CancellationTokenSource _cancellationTokenSource;

public QueueHandler (): base ()

{

_queueInput = "image_input";

_queueOutput = "image_output";

}

public override void Start ()

{

ConnectToMq ();

}

public override void Stop ()

{

_channelInput. BasicCancel (_imageConsumerTag);

_connectionToMQ. Close ();

}

private void ConnectToMq ()

{

var factory = new ConnectionFactory ()

{

HostName = "localhost"

};

_connectionToMQ = factory. CreateConnection ();

_channelInput = _connectionToMQ. CreateModel ();

_channelInput. QueueDeclare (

queue: _queueInput,

durable: false,

exclusive: false,

autoDelete: false,

arguments: null);

_channelInput. BasicQos (0, 1, false);

var imageConsumer = new EventingBasicConsumer (_channelInput);

imageConsumer. Received += MessageReceived;

_imageConsumerTag = _channelInput. BasicConsume (_queueInput, false, imageConsumer);

}

private void InitConsumer (IModel channelInput)

{

channelInput. QueueDeclare (

queue: _queueInput,

durable: false,

exclusive: false,

autoDelete: false,

arguments: null);

channelInput. BasicQos (0, 1, false);

var imageConsumer = new EventingBasicConsumer (channelInput);

imageConsumer. Received += MessageReceived;

_imageConsumerTag = channelInput. BasicConsume (_queueInput, false, imageConsumer);

}

private void PublishMessage (IModel outputChannel, Guid ticket, byte [] messageBody)

{

var props = outputChannel. CreateBasicProperties ();

props. CorrelationId = ticket. ToString ();

outputChannel. BasicPublish (exchange: "", routingKey: _queueOutput,

basicProperties: props, body: messageBody);

}

private void MessageReceived (object sender, BasicDeliverEventArgs e)

{

byte [] imageData = e. Body;

if (! _cancellationTokenSource. IsCancellationRequested)

{

using (var originalImage = new Bitmap (GetImageFromByteArray (imageData)))

{

byte [] rgba = ImageUtils. GetRgbaFromBitmap (originalImage);

SRCNNHandler srcnn = new SRCNNHandler ()

{

Scale = 2,ScaleModel = Model

};

int width = originalImage. Width;

int height = originalImage. Height;

Task upscallingTask = Task.run (

() => srcnn. UpscaleImageAsync (rgba, width, height, ResultHandling,

ProgressLogging), _cancellationTokenSource. Token);

_imagePrecessingTasks. RemoveAll (t => t. IsCompleted);

_imagePrecessingTasks. Add (upscallingTask);

}

}

}

private void ResultHandling (ResultMessage result)

{

throw new NotImplementedException ();

}

private void ProgressLogging (ProgressMessage message)

{

Console. WriteLine (message);

}

private Image GetImageFromByteArray (byte [] file)

{

using (MemoryStream mStream = new MemoryStream (file))

{

return Image. FromStream (mStream);

}

}

}

}

using System. IO;

using System. Linq;

using System. Reflection;

using ImageSuperResolution. SRCNN. Handler. Upscalling;

namespace ImageSuperResolution. SRCNN. Handler. Services

{

public abstract class UpscallingServiceBase

{

protected readonly SRCNNModelLayer [] Model;

public UpscallingServiceBase ()

{

Model = LoadModel ();

}

public abstract void Start ();

public abstract void Stop ();

private SRCNNModelLayer [] LoadModel ()

{

var assembly = typeof (UpscallingServiceBase). GetTypeInfo (). Assembly;

string [] names = assembly. GetManifestResourceNames ();

Stream modelResource = assembly. GetManifestResourceStream (names. First (name => name. Contains ("model. json")));

string jsonModel;

using (var sr = new StreamReader (modelResource))

{

jsonModel = sr. ReadToEnd ();

}

return SRCNNModelLayer. ReadModel (jsonModel);

}

}

}

using System;

using System.componentModel;

using System. Reflection;

namespace ImageSuperResolution. SRCNN. Handler. Messages. Helpers

{

public static class ReflectionHelpers

{

public static string GetCustomDescription (object objEnum)

{

var fi = objEnum. GetType (). GetField (objEnum. ToString ());

var attributes = (DescriptionAttribute []) fi. GetCustomAttributes (typeof (DescriptionAttribute), false);

return (attributes. Length > 0)? attributes [0]. Description: objEnum. ToString ();

}

public static string Description (this Enum value)

{

return GetCustomDescription (value);

}

}

}

using System;

using System. Collections. Generic;

using System. Drawing;

using System. Linq;

using System. Threading. Tasks;

namespace ImageSuperResolution. SRCNN. Handler. Messages

{

public class BlockUpscalling: ProgressMessage

{

public int TotalBlocks { get; set; }

public int BlockNumber { get; set; }

public BlockUpscalling (int blockNumber, int totalBlocks): base (UpscallingStatuses. UpscallingBlock, "scalling block")

{

BlockNumber = blockNumber;

TotalBlocks = totalBlocks;

}

public override string ToString ()

{

return $"{base. ToString () } (block {BlockNumber} of {TotalBlocks})";

}

}

}

using System;

using System. Collections. Generic;

using System. Linq;

using System. Threading. Tasks;

using ImageSuperResolution. SRCNN. Handler. Messages. Helpers;

namespace ImageSuperResolution. SRCNN. Handler. Messages

{

public class ProgressMessage

{

public int? Percent { get; set; } = null;

public string Message { get; set; }

public UpscallingStatuses Phase { get; set; }

public ProgressMessage (UpscallingStatuses phase, string message)

{

Phase = phase;

Message = message;

}

public ProgressMessage ()

{

}

public override string ToString ()

{

if (Percent! = null)

{

return $"{Phase. Description () } ({Percent}%): {Message}";

}

else

{

return $"{Phase. Description () }: {Message}";

}

}

}

}

using System;

using System. Collections. Generic;

using System. Linq;

using System. Threading. Tasks;

namespace ImageSuperResolution. SRCNN. Handler. Messages

{

public class ResultMessage

{

public byte [] ImageRgba { get; set; }

public TimeSpan ElapsedTime { get; set; }

public int ImageWidth { get; set; }

public int ImageHeight { get; set; }

public ResultMessage (byte [] image, int width, int height, TimeSpan time)

{

ImageRgba = image;

ImageWidth = width;

ImageHeight = height;

ElapsedTime = time;

}

public override string ToString ()

{

return $"Image ({ImageRgba. Length} bytes) was upscaled to width {ImageWidth}px and height {ImageHeight}px for {ElapsedTime: g}";

}

}

}

using System;

using System. Collections. Generic;

using System.componentModel;

using System. Linq;

using System. Threading. Tasks;

namespace ImageSuperResolution. SRCNN. Handler. Messages

{

public enum UpscallingStatuses

{

[Description ("Decomposing")]

Decompose,

[Description ("Upscalling block")]

UpscallingBlock,

[Description ("Composing")]

Compose

}

}

using System;

using System. Collections. Generic;

using System. Drawing;

using System. Drawing. Imaging;

using System. IO;

using System. Threading;

using System. Threading. Tasks;

using ImageSuperResolution. SRCNN. Handler. Messages;

using ImageSuperResolution. SRCNN. Handler. Upscalling;

namespace ImageSuperResolution. SRCNN. Handler. Services

{

public class FileStubHandler: UpscallingServiceBase

{

private string _directoryInput;

private string _directoryOutput;

private ImageWatcherService _watcher;

private readonly List<Task> _imagePrecessingTasks;

private readonly CancellationTokenSource _cancellationTokenSource;

public FileStubHandler (): base ()

{

InitFolders ();

_imagePrecessingTasks = new List<Task> ();

_cancellationTokenSource = new CancellationTokenSource ();

}

public override void Start ()

{

_watcher = new ImageWatcherService (_directoryInput);

_watcher. OnNewFileFound += ProceedImage;

_watcher. StartWatching ();

}

public override void Stop ()

{

Console. WriteLine ("Cancel requested. ");

_watcher. StopWatching ();

_cancellationTokenSource. Cancel ();

Task. WaitAll (_imagePrecessingTasks. ToArray ());

}

private void ProceedImage (object sender, string pathToImage)

{

if (! _cancellationTokenSource. IsCancellationRequested)

{

using (var originalImage = new Bitmap (pathToImage))

{

var rgba = ImageUtils. GetRgbaFromBitmap (originalImage);

SRCNNHandler srcnn = new SRCNNHandler ()

{

Scale = 2,ScaleModel = Model

};

int width = originalImage. Width;

int height = originalImage. Height;

Task upscallingTask = Task.run (

() => srcnn. UpscaleImageAsync (rgba, width, height, ResultHandling,

ProgressLogging), _cancellationTokenSource. Token);

_imagePrecessingTasks. RemoveAll (t => t. IsCompleted);

_imagePrecessingTasks. Add (upscallingTask);

}

File. Delete (pathToImage);

}

}

private void ProgressLogging (ProgressMessage message)

{

Console. WriteLine (message);

}

private void ResultHandling (ResultMessage result)

{

var newImage = ImageUtils. GetBitmapFromRgba (result. ImageWidth, result. ImageHeight, result. ImageRgba);

string filename = $"{DateTime. Now: yy-MM-dd hh-mm-ss}. png";

newImage. Save (Path.combine (_directoryOutput, filename), ImageFormat. Png);

Console. WriteLine (result);

}

private void InitFolders ()

{

_directoryInput = Path.combine (Directory. GetCurrentDirectory (), "ImageInputStub");

_directoryOutput = Path.combine (Directory. GetCurrentDirectory (), "ImageOutputStub");

Directory. CreateDirectory (_directoryInput);

Directory. CreateDirectory (_directoryOutput);

}

}

}

using System;

using System. Collections. Generic;

using System. IO;

using System. Linq;

using System. Threading;

using System. Threading. Tasks;

namespace ImageSuperResolution. SRCNN. Handler. Services

{

public class ImageWatcherService

{

public string DirectoryWithImages { get; private set; }

private CancellationTokenSource _cancellationTokenSource;

public event EventHandler<string> OnNewFileFound;

public ImageWatcherService (string directoryWithImages)

{

DirectoryWithImages = directoryWithImages;

}

public void StartWatching ()

{

_cancellationTokenSource = new CancellationTokenSource ();

Watching (_cancellationTokenSource. Token);

}

public void StopWatching ()

{

_cancellationTokenSource. Cancel ();

}

private void Watching (CancellationToken token)

{

Task.run ( () =>

{

while (true)

{

token. ThrowIfCancellationRequested ();

string [] imagePaths = Directory. GetFiles (DirectoryWithImages);

if (imagePaths. Any ())

{

string imagePath = imagePaths. First (s => s. EndsWith (". bmp") || s. EndsWith (". png") || s. EndsWith (". jpg"));

OnNewFileFound?. Invoke (this, imagePath);

}

}

}, token);

}

}

}

Приложение B. Диаграмма последовательностей загрузки изображения для масштабирования