public void Process(Bitmap imgSource, IProcessorCommand command)
{
if (imgSource == null || !Actions.ContainsKey(command.Command))
{
return;
}
var action = Actions[command.Command];
var data = imgSource.GetBitmapData();
var bof = data.GetBof();
var pixelBytes = imgSource.GetPixelBytes();
var byteCount = pixelBytes * data.Width;
Parallel.For(0, data.Height, y =>
{
var currentPointer = bof + y * data.Stride;
var beforePointer = bof + (y - 1) * data.Stride;
var afterPointer = bof + (y + 1) * data.Stride;
for (var x = 0; x < byteCount - 9; x += pixelBytes)
{
action.Process(currentPointer, beforePointer, afterPointer, x, x - pixelBytes, x + pixelBytes);
}
});
imgSource.UnlockBits(data);
}
public void ProcessorCommand_NotEqualsHashCodesForDifferentCommand()
{
//Arrange
IProcessorCommand addCommand = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Add);
addCommand.Id = "1";
IProcessorCommand subCommand = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Subtract);
subCommand.Id = "1";
IProcessorCommand tranCommand = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Transpose);
tranCommand.Id = "1";
IProcessorCommand multCommand = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Multiply);
multCommand.Id = "1";
IProcessorCommand badCommand = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Bad);
badCommand.Id = "1";
//Act
//Assert
Assert.NotEqual(addCommand.GetHashCode(), subCommand.GetHashCode());
Assert.NotEqual(addCommand.GetHashCode(), tranCommand.GetHashCode());
Assert.NotEqual(addCommand.GetHashCode(), multCommand.GetHashCode());
Assert.NotEqual(addCommand.GetHashCode(), badCommand.GetHashCode());
}
public static IProcessorCommand GetProcessor(Operator operation, IEnumerable <Matrix <int> > matrices)
{
IProcessorCommand command = GetProcessor(operation);
command.Source = matrices;
return(command);
}
public void ProcessorCommand_EqualsForSameCommand()
{
//Arrange
IProcessorCommand addCommand = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Add);
addCommand.Id = "1";
IProcessorCommand subCommand = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Subtract);
subCommand.Id = "1";
IProcessorCommand tranCommand = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Transpose);
tranCommand.Id = "1";
IProcessorCommand multCommand = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Multiply);
multCommand.Id = "1";
IProcessorCommand badCommand = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Bad);
badCommand.Id = "1";
IProcessorCommand addCommand3 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Add);
addCommand3.Id = "1";
IProcessorCommand subCommand3 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Subtract);
subCommand3.Id = "1";
IProcessorCommand tranCommand3 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Transpose);
tranCommand3.Id = "1";
IProcessorCommand multCommand3 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Multiply);
multCommand3.Id = "1";
IProcessorCommand badCommand3 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Bad);
badCommand3.Id = "1";
//Act
//Assert
Assert.Equal(addCommand, addCommand3);
Assert.Equal(subCommand, subCommand3);
Assert.Equal(tranCommand, tranCommand3);
Assert.Equal(multCommand, multCommand3);
Assert.Equal(badCommand, badCommand3);
}
public void Process(Bitmap imgSource, IProcessorCommand command)
{
var histogram = GetGrayscaleHistogram(imgSource);
var median = CalculateMedian(histogram).ToArgb();
var data = imgSource.GetBitmapData();
var bof = data.GetBof();
var pixelBytes = imgSource.GetPixelBytes();
var byteCount = pixelBytes * data.Width;
Parallel.For(0, data.Height, y =>
{
var currentPointer = bof + y * data.Stride;
for (var x = 0; x < byteCount; x += pixelBytes)
{
Process(currentPointer, x, median);
}
});
imgSource.UnlockBits(data);
}
public static bool TryMapTo(this DataContentModel fromModel, out IProcessorCommand toModel)
{
if (fromModel == null)
{
throw new ArgumentNullException(nameof(fromModel));
}
//Right command contains minimum 3 lines: operation, empty and matrix
if (fromModel.ContentStrings.Length < 3 ||
!string.IsNullOrWhiteSpace(fromModel.ContentStrings[1]) ||
string.IsNullOrWhiteSpace(fromModel.ContentStrings[2]))
{
//It is not command file, skip
toModel = null;
return(false);
}
string strOperation = fromModel.ContentStrings[0];
if (!Enum.TryParse(strOperation, true, out ProcessorCommandFabric.Operator operation))
{
//It is not command file, skip
toModel = null;
return(false);
}
IProcessorCommand processor = ProcessorCommandFabric.GetProcessor(operation);
if (!fromModel.TryMapTo(out IEnumerable <Matrix <int> > matrices))
{
//It is a command file, but wrong data, return BadCommand
toModel = ProcessorCommandFabric.GetBadProcessor(fromModel.FilePath);
return(true);
}
processor.Source = matrices;
processor.Id = fromModel.FilePath;
toModel = processor;
return(true);
}
public void Process(Bitmap imgSource, IProcessorCommand command)
{
if (imgSource == null || !Actions.ContainsKey(command.Command))
{
return;
}
var action = Actions[command.Command];
var channel = EnumUtil.Convert <ARGBChannel>(command.Parameter.ToUpper());
var data = imgSource.GetBitmapData();
var bof = data.GetBof();
var pixelBytes = imgSource.GetPixelBytes();
var byteCount = pixelBytes * data.Width;
Parallel.For(0, data.Height, y =>
{
var currentPointer = bof + y * data.Stride;
for (var x = 0; x < byteCount; x += pixelBytes)
{
action.Process(currentPointer, x, channel);
}
});
imgSource.UnlockBits(data);
}
public static bool TryMapTo(this IProcessorCommand fromModel, out DataContentModel toModel)
{
if (fromModel == null)
{
throw new ArgumentNullException(nameof(fromModel));
}
if (fromModel is BadProcessorCommand || !fromModel.IsCalculated)
{
toModel = null;
return(false);
}
toModel = new DataContentModel
{
FilePath = fromModel.Id + "_result.txt"
};
List <string> lstToModel = new List <string>();
bool firstMatrix = true;
foreach (Matrix <int> matrix in fromModel.Result)
{
if (!firstMatrix)
{
lstToModel.Add(string.Empty);
}
if (!matrix.TryMapTo(out IEnumerable <string> lstMatrix))
{
toModel = null;
return(false);
}
lstToModel.AddRange(lstMatrix);
firstMatrix = false;
}
toModel.ContentStrings = lstToModel.ToArray();
return(true);
}
public void Process(Bitmap imgSource, IProcessorCommand command)
{
Processors[command.Mode]
.Process(imgSource, command);
}
public void ProcessorCommand_NotEqualsForDifferentCommand()
{
//Arrange
IProcessorCommand addCommand = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Add);
addCommand.Id = "1";
IProcessorCommand subCommand = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Subtract);
subCommand.Id = "1";
IProcessorCommand tranCommand = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Transpose);
tranCommand.Id = "1";
IProcessorCommand multCommand = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Multiply);
multCommand.Id = "1";
IProcessorCommand badCommand = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Bad);
badCommand.Id = "1";
IProcessorCommand addCommand2 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Add);
addCommand2.Id = "2";
IProcessorCommand subCommand2 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Subtract);
subCommand2.Id = "2";
IProcessorCommand tranCommand2 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Transpose);
tranCommand2.Id = "2";
IProcessorCommand multCommand2 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Multiply);
multCommand2.Id = "2";
IProcessorCommand badCommand2 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Bad);
badCommand2.Id = "2";
List <Matrix <int> > lstMatrix = new List <Matrix <int> >
{
new Matrix <int>
{
Data = new int[, ] {
{ 1, 2, 3, 4, 5 },
}
}
};
IProcessorCommand addCommand4 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Add, lstMatrix);
addCommand4.Id = "1";
IProcessorCommand subCommand4 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Subtract, lstMatrix);
subCommand4.Id = "1";
IProcessorCommand tranCommand4 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Transpose, lstMatrix);
tranCommand4.Id = "1";
IProcessorCommand multCommand4 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Multiply, lstMatrix);
multCommand4.Id = "1";
IProcessorCommand badCommand4 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Bad, lstMatrix);
badCommand4.Id = "1";
List <Matrix <int> > lstMatrix3 = new List <Matrix <int> >
{
new Matrix <int>
{
Data = new int[, ] {
{ 100, 2, 3, 4, 5 },
}
}
};
IProcessorCommand addCommand3 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Add, lstMatrix3);
addCommand3.Id = "1";
IProcessorCommand subCommand3 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Subtract, lstMatrix3);
subCommand3.Id = "1";
IProcessorCommand tranCommand3 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Transpose, lstMatrix3);
tranCommand3.Id = "1";
IProcessorCommand multCommand3 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Multiply, lstMatrix3);
multCommand3.Id = "1";
IProcessorCommand badCommand3 = ProcessorCommandFabric.GetProcessor(ProcessorCommandFabric.Operator.Bad, lstMatrix3);
badCommand3.Id = "1";
//Act
//Assert
Assert.NotEqual(addCommand, subCommand);
Assert.NotEqual(addCommand, tranCommand);
Assert.NotEqual(addCommand, multCommand);
Assert.NotEqual(addCommand, badCommand);
Assert.NotEqual(addCommand, addCommand2);
Assert.NotEqual(subCommand, subCommand2);
Assert.NotEqual(tranCommand, tranCommand2);
Assert.NotEqual(multCommand, multCommand2);
Assert.NotEqual(badCommand, badCommand2);
Assert.NotEqual(addCommand, addCommand4);
Assert.NotEqual(subCommand, subCommand4);
Assert.NotEqual(tranCommand, tranCommand4);
Assert.NotEqual(multCommand, multCommand4);
Assert.NotEqual(badCommand, badCommand4);
Assert.NotEqual(addCommand3, addCommand4);
Assert.NotEqual(subCommand3, subCommand4);
Assert.NotEqual(tranCommand3, tranCommand4);
Assert.NotEqual(multCommand3, multCommand4);
Assert.NotEqual(badCommand3, badCommand4);
Assert.NotEqual(addCommand.GetHashCode(), subCommand.GetHashCode());
Assert.NotEqual(addCommand.GetHashCode(), tranCommand.GetHashCode());
Assert.NotEqual(addCommand.GetHashCode(), multCommand.GetHashCode());
Assert.NotEqual(addCommand.GetHashCode(), badCommand.GetHashCode());
}
