public void write_video_test()
{
var videoWriter = new VideoFileWriter();
int width = 800;
int height = 600;
int framerate = 24;
string path = Path.GetFullPath("output.avi");
int videoBitRate = 1200 * 1000;
//int audioBitRate = 320 * 1000;
videoWriter.Open(path, width, height, framerate, VideoCodec.H264, videoBitRate);
var m2i = new MatrixToImage();
Bitmap frame;
for (byte i = 0; i < 255; i++)
{
byte[,] matrix = Matrix.Create(height, width, i);
m2i.Convert(matrix, out frame);
videoWriter.WriteVideoFrame(frame, TimeSpan.FromSeconds(i));
}
videoWriter.Close();
Assert.IsTrue(File.Exists(path));
}
public void ConvertTest2()
{
// Create a matrix representation
// of a 4x4 image with a inner 2x2
// square drawn in the middle
double[,] pixels =
{
{ 0, 0, 0, 0 },
{ 0, 1, 1, 0 },
{ 0, 1, 1, 0 },
{ 0, 0, 0, 0 },
};
// Create the converter to convert the matrix to a image
MatrixToImage conv = new MatrixToImage(min: 0, max: 1);
// Declare an image and store the pixels on it
Bitmap image; conv.Convert(pixels, out image);
// Show the image on screen
image = new ResizeNearestNeighbor(320, 320).Apply(image);
// ImageBox.Show(image, PictureBoxSizeMode.Zoom);
Assert.AreEqual(0, conv.Min);
Assert.AreEqual(1, conv.Max);
Assert.AreEqual(320, image.Height);
Assert.AreEqual(320, image.Width);
}
public void ConvertTest2()
{
// Create a matrix representation
// of a 4x4 image with a inner 2x2
// square drawn in the middle
double[,] pixels =
{
{ 0, 0, 0, 0 },
{ 0, 1, 1, 0 },
{ 0, 1, 1, 0 },
{ 0, 0, 0, 0 },
};
// Create the converter to convert the matrix to a image
var conv = new MatrixToBitmapSource();
// Declare a bitmap source and store the pixels on it
BitmapSource image; conv.Convert(pixels, out image);
var conv2 = new MatrixToImage();
Bitmap image2; conv2.Convert(pixels, out image2);
Assert.AreEqual(pixels, image.ToMatrix(0));
Assert.AreEqual(pixels, image2.ToMatrix(0));
Assert.AreEqual(PixelFormats.Gray32Float, image.Format);
Assert.AreEqual(System.Drawing.Imaging.PixelFormat.Format8bppIndexed, image2.PixelFormat);
}
public void write_video_test()
{
var videoWriter = new VideoFileWriter();
int width = 800;
int height = 600;
int framerate = 24;
string path = Path.GetFullPath(Path.Combine(TestContext.CurrentContext.TestDirectory, "output.avi"));
int videoBitRate = 1200 * 1000;
videoWriter.Open(path, width, height, framerate, VideoCodec.H264, videoBitRate);
Assert.AreEqual(videoBitRate, videoWriter.BitRate);
var m2i = new MatrixToImage();
Bitmap frame;
for (byte i = 0; i < 255; i++)
{
byte[,] matrix = Matrix.Create(height, width, i);
m2i.Convert(matrix, out frame);
videoWriter.WriteVideoFrame(frame, TimeSpan.FromSeconds(i));
}
videoWriter.Close();
Assert.IsTrue(File.Exists(path));
}
public static Bitmap ToBitmap(double[,] rawImage)
{
MatrixToImage mtrxToImage = new MatrixToImage();
UnmanagedImage outputImage = null;
mtrxToImage.Convert(rawImage, out outputImage);
return(outputImage.ToManagedImage());
}
public static Bitmap ToBitmap(float[,] texture)
{
MatrixToImage i2m = new MatrixToImage();
Bitmap image;
i2m.Convert(texture, out image);
return(image);
}
static void TestFFMPEG()
{
var videoWriter = new VideoFileWriter();
int width = 800;
int height = 600;
int framerate = 24;
string path = Path.GetFullPath("output.webm");
int videoBitRate = 1200 * 1000;
int audioFrameSize = 44100;
int audioBitRate = 128000;
int audioSampleRate = 44100;
AudioLayout audioChannels = AudioLayout.Mono;
videoWriter.Width = width;
videoWriter.Height = height;
videoWriter.FrameRate = framerate;
videoWriter.VideoCodec = VideoCodec.Vp8;
videoWriter.BitRate = videoBitRate;
videoWriter.PixelFormat = AVPixelFormat.FormatYuv420P;
videoWriter.Open(path);
//, audioFrameSize, audioChannels, audioSampleRate, AudioCodec.Vorbis, audioBitRate);
var a = new Accord.DirectSound.AudioDeviceCollection(DirectSound.AudioDeviceCategory.Capture);
// Generate 1 second of audio
SineGenerator gen = new SineGenerator()
{
SamplingRate = audioSampleRate,
Channels = 1,
Format = SampleFormat.Format16Bit,
Frequency = 10,
Amplitude = 1000.9f,
};
Signal s = gen.Generate(TimeSpan.FromSeconds(255));
//s.Save("test.wav");
var m2i = new MatrixToImage();
Bitmap frame;
for (byte i = 0; i < 255; i++)
{
byte[,] matrix = Matrix.Create(height, width, i);
m2i.Convert(matrix, out frame);
videoWriter.WriteVideoFrame(frame, TimeSpan.FromSeconds(1));
//// Generate 1 second of audio
//s = gen.Generate(TimeSpan.FromSeconds(1));
//videoWriter.WriteAudioFrame(s);
}
videoWriter.Close();
}
static void TestFFMPEG2()
{
string outputPath = Path.GetFullPath("output.avi");
// First, we create a new VideoFileWriter:
var videoWriter = new VideoFileWriter()
{
// Our video will have the following characteristics:
Width = 800,
Height = 600,
FrameRate = 24,
BitRate = 1200 * 1000,
VideoCodec = VideoCodec.Mpeg4,
//PixelFormat = Accord.Video.FFMPEG.PixelFormat.FormatYUV420P
};
// We can open for it writing:
videoWriter.Open(outputPath);
// At this point, we can check the console of our application for useful
// information regarding our media streams created by FFMPEG. We can also
// check those properties using the class itself, specially for properties
// that we didn't set beforehand but that have been filled by FFMPEG:
int width = videoWriter.Width;
int height = videoWriter.Height;
int frameRate = videoWriter.FrameRate.Numerator;
int bitRate = videoWriter.BitRate;
VideoCodec videoCodec = videoWriter.VideoCodec;
// We haven't set those properties, but FFMPEG has filled them for us:
AudioCodec audioCodec = videoWriter.AudioCodec;
int audioSampleRate = videoWriter.SampleRate;
AudioLayout audioChannels = videoWriter.AudioLayout;
int numberOfChannels = videoWriter.NumberOfChannels;
// Now, let's say we would like to save dummy images of changing color
var m2i = new MatrixToImage();
Bitmap frame;
for (byte i = 0; i < 255; i++)
{
// Create bitmap matrix from a matrix of RGB values:
byte[,] matrix = Matrix.Create(height, width, i);
m2i.Convert(matrix, out frame);
// Write the frame to the stream. We can optionally specify
// the duration that this frame should remain in the stream:
videoWriter.WriteVideoFrame(frame, TimeSpan.FromSeconds(i));
}
}
public void ConvertTest1()
{
MatrixToImage target = new MatrixToImage();
double[,] pixels =
{
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 0
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 1
{ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, // 2
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 3
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 4
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 5
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 6
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 7
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 8
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 9
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 10
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 11new Bitmap(Properties
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 12
{ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, // 13
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 14
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 15
};
Bitmap imageActual;
target.Convert(pixels, out imageActual);
double[,] actual;
ImageToMatrix c = new ImageToMatrix();
c.Convert(imageActual, out actual);
double[,] expected;
Bitmap imageExpected = Accord.Imaging.Image.Clone(Resources.image1);
new Threshold().ApplyInPlace(imageExpected);
new Invert().ApplyInPlace(imageExpected);
c.Convert(imageExpected, out expected);
for (int i = 0; i < pixels.GetLength(0); i++)
{
for (int j = 0; j < pixels.GetLength(1); j++)
{
Assert.AreEqual(actual[i, j], expected[i, j]);
}
}
}
public static BitmapSource CreateBitmapSource(byte[,] input)
{
try
{
MatrixToImage Matrix2Bitmap = new MatrixToImage();
Bitmap bitout = new Bitmap(input.GetLength(0), input.GetLength(1));
Matrix2Bitmap.Convert(input, out bitout);
BitmapSource bitsource = ToWpfBitmap(bitout);
return(bitsource);
}
catch (Exception)
{
return(null);
}
}
private static void write_and_open(Rational framerate, int num, int den)
{
int width = 800;
int height = 600;
string path = Path.GetFullPath(Path.Combine(TestContext.CurrentContext.TestDirectory, "output2.avi"));
int videoBitRate = 1200 * 1000;
{
var videoWriter = new VideoFileWriter();
videoWriter.Open(path, width, height, framerate, VideoCodec.FfvHuff, videoBitRate);
Assert.AreEqual(width, videoWriter.Width);
Assert.AreEqual(height, videoWriter.Height);
Assert.AreEqual(videoBitRate, videoWriter.BitRate);
Assert.AreEqual(num, videoWriter.FrameRate.Numerator);
Assert.AreEqual(den, videoWriter.FrameRate.Denominator);
var m2i = new MatrixToImage();
Bitmap frame;
for (byte i = 0; i < 255; i++)
{
byte[,] matrix = Matrix.Create(height, width, i);
m2i.Convert(matrix, out frame);
videoWriter.WriteVideoFrame(frame, TimeSpan.FromSeconds(i));
}
videoWriter.Close();
}
Assert.IsTrue(File.Exists(path));
{
VideoFileReader reader = new VideoFileReader();
reader.Open(path);
Assert.AreEqual(width, reader.Width);
Assert.AreEqual(height, reader.Height);
//Assert.AreEqual(videoBitRate, reader.BitRate);
Assert.AreEqual(num, reader.FrameRate.Numerator);
Assert.AreEqual(den, reader.FrameRate.Denominator);
}
}
byte[,] SizeDown(byte[,] pickedMat, double scale)
{
Bitmap tempbit = new Bitmap(pickedMat.GetLength(0), pickedMat.GetLength(1));
Matrix2Bitmap.Convert(pickedMat, out tempbit);
pickedMat = null;
Bitmap tempDownbut = new Bitmap(tempbit, new System.Drawing.Size((int)(tempbit.Width / scale), (int)(tempbit.Height / scale)));
tempbit = null;
byte[,] downMat = new byte[tempDownbut.Width, tempDownbut.Height];
Bitmap2matrix.Convert(tempDownbut, out downMat);
return(downMat = Matrix.Transpose(downMat)); // DownScaled byte[,]
}
private static long[,] create(byte[,] img, PixelFormat format)
{
long[,] actual8bpp;
Bitmap image;
MatrixToImage converter = new MatrixToImage();
converter.Format = format;
converter.Convert(img, out image);
Assert.AreEqual(format, image.PixelFormat);
IntegralImage2 ii8bpp = IntegralImage2.FromBitmap(image, 0);
actual8bpp = ii8bpp.Image;
return(actual8bpp);
}
public void ConvertTest2()
{
// Load a test image
Bitmap sourceImage = Accord.Imaging.Image.Clone(Properties.Resources.image1);
// Make sure values are binary
new Threshold().ApplyInPlace(sourceImage);
// Create the converters
ImageToMatrix imageToMatrix = new ImageToMatrix()
{
Min = 0, Max = 255
};
MatrixToImage matrixToImage = new MatrixToImage()
{
Min = 0, Max = 255
};
// Convert to matrix
double[,] matrix; // initialization is not needed
imageToMatrix.Convert(sourceImage, out matrix);
// Revert to image
Bitmap resultImage; // initialization is not needed
matrixToImage.Convert(matrix, out resultImage);
// Show both images, which should be equal
// ImageBox.Show(sourceImage, PictureBoxSizeMode.Zoom);
// ImageBox.Show(resultImage, PictureBoxSizeMode.Zoom);
UnmanagedImage img1 = UnmanagedImage.FromManagedImage(sourceImage);
UnmanagedImage img2 = UnmanagedImage.FromManagedImage(resultImage);
List <IntPoint> p1 = img1.CollectActivePixels();
List <IntPoint> p2 = img2.CollectActivePixels();
bool equals = new HashSet <IntPoint>(p1).SetEquals(p2);
Assert.IsTrue(equals);
}
public void ConvertTest()
{
MatrixToImage target = new MatrixToImage(min: 0, max: 128);
byte[,] input =
{
{ 0, 0, 0 },
{ 0, 128, 0 },
{ 0, 0, 128 },
};
UnmanagedImage bitmap;
target.Convert(input, out bitmap);
var pixels = bitmap.CollectActivePixels();
Assert.AreEqual(2, pixels.Count);
Assert.IsTrue(pixels.Contains(new IntPoint(1, 1)));
Assert.IsTrue(pixels.Contains(new IntPoint(2, 2)));
}
/// <summary>
/// Przetworzenie macierzy do Bitmap
/// </summary>
/// <param name="rawImage">Macierz obrazu</param>
/// <returns>Bitmap z obrazem</returns>
public BitmapSource ArrayToBitmapImage(double[,] rawImage)
{
Bitmap imageBitmap;
MatrixToImage conventer = new MatrixToImage(min: 0, max: 1);
conventer.Convert(rawImage, out imageBitmap);
var imageBitmapImage = BitmapToBitmapImage(imageBitmap);
BitmapEncoder encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(imageBitmapImage));
//Testowy zapis pliku wynikowego
//using (var fileStream = new FileStream(@"C:\Users\wilu\Desktop\Filtr medianowy\file.png", FileMode.Create))
//{
// encoder.Save(fileStream);
//}
return(imageBitmapImage);
}
public void ConvertTest()
{
MatrixToImage target = new MatrixToImage(min: 0, max: 128);
byte[,] input =
{
{ 0, 0, 0 },
{ 0, 128, 0 },
{ 0, 0, 128 },
};
UnmanagedImage bitmap;
target.Convert(input, out bitmap);
var pixels = bitmap.CollectActivePixels();
Assert.AreEqual(2, pixels.Count);
Assert.IsTrue(pixels.Contains(new IntPoint(1, 1)));
Assert.IsTrue(pixels.Contains(new IntPoint(2, 2)));
}
public void ConvertTest2()
{
// Load a test image
Bitmap sourceImage = Properties.Resources.image1;
// Make sure values are binary
new Threshold().ApplyInPlace(sourceImage);
// Create the converters
ImageToMatrix imageToMatrix = new ImageToMatrix() { Min = 0, Max = 255 };
MatrixToImage matrixToImage = new MatrixToImage() { Min = 0, Max = 255 };
// Convert to matrix
double[,] matrix; // initialization is not needed
imageToMatrix.Convert(sourceImage, out matrix);
// Revert to image
Bitmap resultImage; // initialization is not needed
matrixToImage.Convert(matrix, out resultImage);
// Show both images, which should be equal
// ImageBox.Show(sourceImage, PictureBoxSizeMode.Zoom);
// ImageBox.Show(resultImage, PictureBoxSizeMode.Zoom);
UnmanagedImage img1 = UnmanagedImage.FromManagedImage(sourceImage);
UnmanagedImage img2 = UnmanagedImage.FromManagedImage(resultImage);
List<IntPoint> p1 = img1.CollectActivePixels();
List<IntPoint> p2 = img2.CollectActivePixels();
bool equals = new HashSet<IntPoint>(p1).SetEquals(p2);
Assert.IsTrue(equals);
}
public void ConvertTest1()
{
MatrixToImage target = new MatrixToImage();
double[,] pixels =
{
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 0
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 1
{ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, // 2
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 3
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 4
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 5
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 6
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 7
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 8
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 9
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 10
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 11
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 12
{ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, // 13
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 14
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 15
};
Bitmap imageActual;
target.Convert(pixels, out imageActual);
double[,] actual;
ImageToMatrix c = new ImageToMatrix();
c.Convert(imageActual, out actual);
double[,] expected;
Bitmap imageExpected = Properties.Resources.image1;
new Threshold().ApplyInPlace(imageExpected);
new Invert().ApplyInPlace(imageExpected);
c.Convert(imageExpected, out expected);
for (int i = 0; i < pixels.GetLength(0); i++)
for (int j = 0; j < pixels.GetLength(1); j++)
Assert.AreEqual(actual[i, j], expected[i, j]);
}
public void ConvertTest2()
{
// Create a matrix representation
// of a 4x4 image with a inner 2x2
// square drawn in the middle
double[,] pixels =
{
{ 0, 0, 0, 0 },
{ 0, 1, 1, 0 },
{ 0, 1, 1, 0 },
{ 0, 0, 0, 0 },
};
// Create the converter to convert the matrix to a image
MatrixToImage conv = new MatrixToImage(min: 0, max: 1);
// Declare an image and store the pixels on it
Bitmap image; conv.Convert(pixels, out image);
// Show the image on screen
image = new ResizeNearestNeighbor(320, 320).Apply(image);
// ImageBox.Show(image, PictureBoxSizeMode.Zoom);
Assert.AreEqual(0, conv.Min);
Assert.AreEqual(1, conv.Max);
Assert.AreEqual(320, image.Height);
Assert.AreEqual(320, image.Width);
}
private static long[,] create(byte[,] img, PixelFormat format)
{
long[,] actual8bpp;
Bitmap image;
MatrixToImage converter = new MatrixToImage();
converter.Format = format;
converter.Convert(img, out image);
Assert.AreEqual(format, image.PixelFormat);
IntegralImage2 ii8bpp = IntegralImage2.FromBitmap(image, 0);
actual8bpp = ii8bpp.Image;
return actual8bpp;
}
public void write_video_new_api()
{
string basePath = TestContext.CurrentContext.TestDirectory;
#region doc_new_api
// Let's say we would like to save file using a .mp4 media
// container, a H.265 video codec for the video stream, and
// AAC for the audio stream, into the file:
string outputPath = Path.Combine(basePath, "output_audio.avi");
// First, we create a new VideoFileWriter:
var videoWriter = new VideoFileWriter()
{
// Our video will have the following characteristics:
Width = 800,
Height = 600,
FrameRate = 24,
BitRate = 1200 * 1000,
VideoCodec = VideoCodec.H265,
AudioCodec = AudioCodec.Aac,
AudioBitRate = 44100,
AudioLayout = AudioLayout.Stereo,
FrameSize = 44100,
PixelFormat = AVPixelFormat.FormatYuv420P
};
// We can open for it writing:
videoWriter.Open(outputPath);
// At this point, we can check the console of our application for useful
// information regarding the media streams created by FFMPEG. We can also
// check those properties using the class itself, specially for properties
// that we didn't set beforehand but that have been filled by FFMPEG:
int width = videoWriter.Width;
int height = videoWriter.Height;
int frameRate = videoWriter.FrameRate.Numerator;
int bitRate = videoWriter.BitRate;
VideoCodec videoCodec = videoWriter.VideoCodec;
AudioCodec audioCodec = videoWriter.AudioCodec;
AudioLayout audioLayout = videoWriter.AudioLayout;
int audioChannels = videoWriter.NumberOfChannels;
// We haven't set those properties, but FFMPEG has filled them for us:
int audioSampleRate = videoWriter.SampleRate;
int audioSampleSize = videoWriter.FrameSize;
// Now, let's say we would like to save dummy images of
// changing color, with a sine wave as the audio stream:
var g = new SineGenerator()
{
Channels = 1, // we will generate only one channel, and the file writer will convert on-the-fly
Format = SampleFormat.Format32BitIeeeFloat,
Frequency = 10f,
Amplitude = 0.9f,
SamplingRate = 44100
};
var m2i = new MatrixToImage();
Bitmap frame;
for (byte i = 0; i < 255; i++)
{
// Create bitmap matrix from a matrix of RGB values:
byte[,] matrix = Matrix.Create(height, width, i);
m2i.Convert(matrix, out frame);
// Write the frame to the stream. We can optionally specify
// the moment when this frame should remain in the stream:
videoWriter.WriteVideoFrame(frame, TimeSpan.FromSeconds(i));
// We can also write the audio samples if we need to:
Signal signal = g.Generate(TimeSpan.FromSeconds(1)); // generate 1 second of audio
videoWriter.WriteAudioFrame(signal); // save it to the stream
}
// We can get how long our written video is:
TimeSpan duration = videoWriter.Duration;
// Close the stream
videoWriter.Close();
#endregion
Assert.AreEqual(2540000000, duration.Ticks);
Assert.AreEqual(800, width);
Assert.AreEqual(600, height);
Assert.AreEqual(24, frameRate);
Assert.AreEqual(1200000, bitRate);
Assert.AreEqual(VideoCodec.H265, videoCodec);
Assert.AreEqual(AudioCodec.Aac, audioCodec);
Assert.AreEqual(44100, audioSampleRate);
Assert.AreEqual(AudioLayout.Stereo, audioLayout);
Assert.AreEqual(2, audioChannels);
}
public void write_video_new_api()
{
string basePath = TestContext.CurrentContext.TestDirectory;
#region doc_new_api
// Let's say we would like to save file using a .avi media
// container and a MPEG4 (DivX/XVid) codec, saving it into:
string outputPath = Path.Combine(basePath, "output_video.avi");
// First, we create a new VideoFileWriter:
var videoWriter = new VideoFileWriter()
{
// Our video will have the following characteristics:
Width = 800,
Height = 600,
FrameRate = 24,
BitRate = 1200 * 1000,
VideoCodec = VideoCodec.Mpeg4,
};
// We can open for it writing:
videoWriter.Open(outputPath);
// At this point, we can check the console of our application for useful
// information regarding the media streams created by FFMPEG. We can also
// check those properties using the class itself, specially for properties
// that we didn't set beforehand but that have been filled by FFMPEG:
int width = videoWriter.Width;
int height = videoWriter.Height;
int frameRate = videoWriter.FrameRate.Numerator;
int bitRate = videoWriter.BitRate;
VideoCodec videoCodec = videoWriter.VideoCodec;
// We haven't set those properties, but FFMPEG has filled them for us:
AudioCodec audioCodec = videoWriter.AudioCodec;
int audioSampleRate = videoWriter.SampleRate;
AudioLayout audioLayout = videoWriter.AudioLayout;
int audioChannels = videoWriter.NumberOfChannels;
// Now, let's say we would like to save dummy images of changing color
var m2i = new MatrixToImage();
Bitmap frame;
for (byte i = 0; i < 255; i++)
{
// Create bitmap matrix from a matrix of RGB values:
byte[,] matrix = Matrix.Create(height, width, i);
m2i.Convert(matrix, out frame);
// Write the frame to the stream. We can optionally specify
// the moment that this frame should remain in the stream:
videoWriter.WriteVideoFrame(frame, TimeSpan.FromSeconds(i));
}
// We can get how long our written video is:
TimeSpan duration = videoWriter.Duration;
// Close the stream
videoWriter.Close();
videoWriter.Dispose();
#endregion
Assert.AreEqual(2540000000, duration.Ticks);
Assert.AreEqual(800, width);
Assert.AreEqual(600, height);
Assert.AreEqual(24, frameRate);
Assert.AreEqual(1200000, bitRate);
Assert.AreEqual(VideoCodec.Mpeg4, videoCodec);
Assert.IsTrue(AudioCodec.Default == audioCodec || AudioCodec.Mp3 == audioCodec);
Assert.AreEqual(44100, audioSampleRate);
Assert.AreEqual(audioLayout, audioLayout);
Assert.AreEqual(2, audioChannels);
}
static void Main(string[] args)
{
var qualityLevels = new Dictionary <int, int[, ]>
{
{ 50, Q50 }
};
foreach (int level in new[] { 10, 20, 30, 40 })
{
int[,] newQ = new int[8, 8];
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
newQ[i, j] = (int)Math.Min(Q50[i, j] * (50d / level), 256d);
}
}
qualityLevels.Add(level, newQ);
}
foreach (int level in new[] { 60, 70, 80, 90, 95 })
{
int[,] newQ = new int[8, 8];
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
newQ[i, j] = (int)Math.Min(Q50[i, j] * ((100d - level) / 50d), 256d);
}
}
qualityLevels.Add(level, newQ);
}
var imageToMatrix = new ImageToMatrix();
var bitmap = new Bitmap(File.OpenRead("sample_blackwhite.bmp"));
double[,] output;
imageToMatrix.Convert(bitmap, out output);
var dct = GetDctMatrix();
var matrixMultiplied = Matrix.Dot(output, dct);
foreach (var q in qualityLevels)
{
double[,] rounded = new double[8, 8];
for (int row = 0; row < 8; row++)
{
for (int column = 0; column < 8; column++)
{
int divided = (int)Math.Round(matrixMultiplied[row, column] * 256d / q.Value[row, column], 0);
int multipliedAgain = divided * q.Value[row, column];
rounded[row, column] = multipliedAgain / 256d;
}
}
var newMatrix = Matrix.Divide(rounded, dct);
var mtoi = new MatrixToImage();
Bitmap bitmap2;
mtoi.Convert(newMatrix, out bitmap2);
bitmap2.Save($"sample_blackwhite_q{q.Key}.bmp");
}
}
private double census(Bitmap myBitmap)
{
int[,] bi = new int[myBitmap.Width, myBitmap.Height];
for (int x = 0; x < myBitmap.Width; x++)
{
for (int y = 0; y < myBitmap.Height; y++)
{
Color pixelColor = myBitmap.GetPixel(x, y);
int mainvalue = pixelColor.R;
string s = "";
try
{
int a0 = myBitmap.GetPixel(x - 1, y - 1).R;
if (a0 >= mainvalue)
{
s = s + 1;
}
else
{
s = s + 0;
}
}
catch (Exception ex)
{
s = s + "";
}
try
{
int a1 = myBitmap.GetPixel(x - 1, y).R;
if (a1 >= mainvalue)
{
s = s + 1;
}
else
{
s = s + 0;
}
}
catch (Exception ex)
{
s = s + "";
}
try
{
int a2 = myBitmap.GetPixel(x - 1, y + 1).R;
if (a2 >= mainvalue)
{
s = s + 1;
}
else
{
s = s + 0;
}
}
catch (Exception ex)
{
s = s + "";
}
try
{
int a3 = myBitmap.GetPixel(x, y - 1).R;
if (a3 >= mainvalue)
{
s = s + 1;
}
else
{
s = s + 0;
}
}
catch (Exception ex)
{
s = s + "";
}
try
{
int a4 = myBitmap.GetPixel(x, y + 1).R;
if (a4 >= mainvalue)
{
s = s + 1;
}
else
{
s = s + 0;
}
}
catch (Exception ex)
{
s = s + "";
}
try
{
int a6 = myBitmap.GetPixel(x + 1, y + 1).R;
if (a6 >= mainvalue)
{
s = s + 1;
}
else
{
s = s + 0;
}
}
catch (Exception ex)
{
s = s + "";
}
try
{
int a7 = myBitmap.GetPixel(x + 1, y).R;
if (a7 >= mainvalue)
{
s = s + 1;
}
else
{
s = s + 0;
}
}
catch (Exception ex)
{
s = s + "";
}
try
{
int a8 = myBitmap.GetPixel(x + 1, y - 1).R;
if (a8 >= mainvalue)
{
s = s + 1;
}
else
{
s = s + 0;
}
}
catch (Exception ex)
{
s = s + "";
}
bi[x, y] = BitStringToInt(s);
// neighbors(1) = img(r - 1, c - 1); % Upper left.r = row, c = column.
// neighbors(2) = img(r - 1, c); % Upper middle.r = row, c = column.
// neighbors(3) = img(r - 1, c + 1); % Upper right.r = row, c = column.
// neighbors(4) = img(r, c - 1); % left.r = row, c = column.
// neighbors(5) = img(r, c + 1); % right.r = row, c = column.
// neighbors(6) = img(r + 1, c + 1); % Lowerleft.r = row, c = column.
// neighbors(7) = img(r + 1, c); % lower middle.r = row, c = column.
// neighbors(8) = img(r + 1, c - 1); % Lower left.r = row, c = column.
// things we do with pixelColor
}
}
MatrixToImage conv = new MatrixToImage(min: 0, max: 255);
// Declare an image and store the pixels on it
Bitmap image; conv.Convert(bi, out image);
Accord.Imaging.ImageStatistics statistics = new Accord.Imaging.ImageStatistics(image);
var histogram = statistics.Gray;
return(histogram.Mean);
}