public void Test_CSV( )
{
string csv =
"TestString,TestNumber\nA,1\nB,2\nC,3\nD,4\nE,5\nA,1\nB,2\nC,3\nD,4\nE,5\n,A,1\nB,2\nC,3\nD,4\nE,5\n";
var service = new CsvFileReaderService( );
var settings = new DataFileReaderSettings( );
SampleDataCreator creator = new SampleDataCreator( );
using (Stream stream = SheetTestHelper.GetCsvStream(csv))
{
SampleTable table = creator.CreateSample(stream, settings, service);
Assert.That(table, Is.Not.Null);
Assert.That(table.Columns, Has.Count.EqualTo(2));
Assert.That(table.Rows, Has.Count.EqualTo(10));
SampleColumn column = table.Columns[0];
Assert.That(column.ColumnName, Is.EqualTo("1"));
Assert.That(column.Name, Is.EqualTo("TestString"));
column = table.Columns[1];
Assert.That(column.ColumnName, Is.EqualTo("2"));
Assert.That(column.Name, Is.EqualTo("TestNumber"));
SampleRow row = table.Rows[0];
Assert.That(row.Values, Has.Count.EqualTo(2));
Assert.That(row.Values[0], Is.EqualTo("A"));
Assert.That(row.Values[1], Is.EqualTo("1"));
row = table.Rows[9];
Assert.That(row.Values, Has.Count.EqualTo(2));
Assert.That(row.Values[0], Is.EqualTo("E"));
Assert.That(row.Values[1], Is.EqualTo("5"));
}
}
public Image Decode(Stream stream)
{
JpegImage jpg = new JpegImage(stream);
int pixelWidth = jpg.Width;
int pixelHeight = jpg.Height;
byte[] pixels = new byte[pixelWidth * pixelHeight * 4];
if (!(jpg.Colorspace == Colorspace.RGB && jpg.BitsPerComponent == 8))
{
throw new NotSupportedException("JpegDecoder only support RGB color space.");
}
for (int y = 0; y < pixelHeight; y++)
{
SampleRow row = jpg.GetRow(y);
for (int x = 0; x < pixelWidth; x++)
{
Sample sample = row.GetAt(x);
int offset = (y * pixelWidth + x) * 4;
pixels[offset + 0] = (byte)sample[2];
pixels[offset + 1] = (byte)sample[1];
pixels[offset + 2] = (byte)sample[0];
pixels[offset + 3] = (byte)255;
}
}
return(new Image(pixelWidth, pixelHeight, pixels));
}
public void Test_Excel_Test2_NoHeadingRow( )
{
var service = new ExcelFileReaderService( );
SampleDataCreator creator = new SampleDataCreator( );
using (Stream stream = SheetTestHelper.GetStream("SampleDataTests.xlsx")) // IMPORTANT: Ensure TestRowNumbers has the right number of rows
{
var settings = new DataFileReaderSettings( );
settings.SheetId = SheetTestHelper.GetSheetId("SampleDataTests.xlsx", "Test2");
settings.HeadingRowNumber = 0;
settings.FirstDataRowNumber = 3;
SampleTable table = creator.CreateSample(stream, settings, service);
Assert.That(table, Is.Not.Null);
Assert.That(table.Columns, Has.Count.EqualTo(3));
Assert.That(table.Rows, Has.Count.EqualTo(2));
SampleColumn column = table.Columns [0];
Assert.That(column.ColumnName, Is.EqualTo("A"));
Assert.That(column.Name, Is.EqualTo("A"));
column = table.Columns [2];
Assert.That(column.ColumnName, Is.EqualTo("C"));
Assert.That(column.Name, Is.EqualTo("C"));
SampleRow row = table.Rows [0];
Assert.That(row.Values, Has.Count.EqualTo(3));
Assert.That(row.Values [2], Is.EqualTo("3"));
}
}
public void Encode(Image image, Stream stream)
{
int pixelWidth = image.Width;
int pixelHeight = image.Height;
byte[] sourcePixels = image.Pixels;
SampleRow[] rows = new SampleRow[pixelHeight];
for (int y = 0; y < pixelHeight; y++)
{
byte[] samples = new byte[pixelWidth * 3];
for (int x = 0; x < pixelWidth; x++)
{
int start = x * 3;
int source = (y * pixelWidth + x) * 4;
samples[start] = sourcePixels[source + 2];
samples[start + 1] = sourcePixels[source + 1];
samples[start + 2] = sourcePixels[source];
}
rows[y] = new SampleRow(samples, pixelWidth, 8, 3);
}
JpegImage jpg = new JpegImage(rows, Colorspace.RGB);
jpg.WriteJpeg(stream, new CompressionParameters {
Quality = Quality
});
}
void PopulateList()
{
foreach (var item in itemList)
{
GameObject newRow = Instantiate(sampleRow) as GameObject;
newRow.transform.SetParent(contentPanel, false);
SampleRow row = newRow.GetComponent <SampleRow>();
row.nameLabel.text = item.name;
row.waveLabel.text = item.wave;
row.scoreLabel.text = item.score;
}
}
private static JpegImage createImageFromPixels()
{
byte[] rowData = new byte[96];
for (int i = 0; i < rowData.Length; ++i)
{
if (i < 5)
{
rowData[i] = 0xE4;
}
else if (i < 15)
{
rowData[i] = 0xAB;
}
else if (i < 35)
{
rowData[i] = 0x00;
}
else if (i < 55)
{
rowData[i] = 0x65;
}
else
{
rowData[i] = 0xF0;
}
}
const int width = 24;
const int height = 25;
const byte bitsPerComponent = 8;
const byte componentsPerSample = 4;
const Colorspace colorspace = Colorspace.CMYK;
SampleRow row = new SampleRow(rowData, width, bitsPerComponent, componentsPerSample);
SampleRow[] rows = new SampleRow[height];
for (int i = 0; i < rows.Length; ++i)
{
rows[i] = row;
}
JpegImage jpegImage = new JpegImage(rows, colorspace);
Assert.AreEqual(jpegImage.Width, width);
Assert.AreEqual(jpegImage.Height, rows.Length);
Assert.AreEqual(jpegImage.BitsPerComponent, bitsPerComponent);
Assert.AreEqual(jpegImage.ComponentsPerSample, componentsPerSample);
Assert.AreEqual(jpegImage.Colorspace, colorspace);
return(jpegImage);
}
// row 자동 생성
private void AddRows()
{
itemList = UIManager.Instance.itemList;
for (int i = 0; i < itemList.Count; i += 3)
{
GameObject newRow = UIManager.Instance.rowObjPool.GetObject();
newRow.transform.SetParent(contentPanel, false);
SampleRow sampleRow = newRow.GetComponent <SampleRow>();
int endIdx = (itemList.Count - 1) < (i + 2) ? (itemList.Count - 1) : (i + 2);
sampleRow.AddItems(i, endIdx);
}
}
public JpegImage Concatenate(JpegImage[,] images, IProgress prog = null)
{
if (images is null)
{
throw new ArgumentNullException(nameof(images));
}
this.ValidateImages(images, prog,
out var rows, out var columns, out var components,
out var tileWidth,
out var tileHeight);
var bufferWidth = columns * tileWidth;
var bufferHeight = rows * tileHeight;
var combined = new SampleRow[bufferHeight];
for (var tileY = 0; tileY < rows; ++tileY)
{
for (var y = 0; y < tileHeight; ++y)
{
var rowBuffer = new byte[bufferWidth];
for (var tileX = 0; tileX < columns; ++tileX)
{
var tile = images[tileY, tileX];
if (tile is object)
{
images[tileY, tileX] = null;
var tileRowBuffer = tile.GetRow(y).ToBytes();
Array.Copy(tileRowBuffer, 0, rowBuffer, tileX * tileWidth * components, tileRowBuffer.Length);
tile.Dispose();
GC.Collect();
}
}
combined[(tileY * tileHeight) + y] = new SampleRow(rowBuffer, bufferWidth, Units.Bits.PER_BYTE, (byte)components);
}
}
return(new JpegImage(combined, Colorspace.RGB));
}
/// <summary>
/// Encodes a raw file buffer of image data into a JPEG image.
/// </summary>
/// <param name="outputStream">Jpeg bytes.</param>
public JpegImage Translate(ImageData image, IProgress prog = null)
{
if (image is null)
{
throw new ArgumentNullException(nameof(image));
}
var subProgs = prog.Split("Copying", "Saving");
var copyProg = subProgs[0];
var saveProg = subProgs[1];
var imageData = image.GetData();
var rows = new SampleRow[image.Info.Dimensions.Height];
var components = (byte)Math.Min(image.Info.Components, 3);
var rowBuffer = new byte[image.Info.Dimensions.Width * components];
for (var y = 0; y < image.Info.Dimensions.Height; ++y)
{
copyProg.Report(y, image.Info.Dimensions.Height);
for (var x = 0; x < image.Info.Dimensions.Width; ++x)
{
var imageDataIndex = (y * image.Info.Stride) + (x * image.Info.Components);
var rowIndex = x * components;
Array.Copy(imageData, imageDataIndex, rowBuffer, rowIndex, components);
}
rows[y] = new SampleRow(
rowBuffer,
image.Info.Dimensions.Width,
Units.Bits.PER_BYTE,
components);
copyProg.Report(y + 1, image.Info.Dimensions.Height);
}
saveProg.Report(0);
var jpeg = new JpegImage(rows, Colorspace.RGB);
saveProg.Report(1);
return(jpeg);
}
/// <summary>
/// Decodes the image from the specified stream and sets
/// the data to image.
/// </summary>
/// <param name="image">The image, where the data should be set to.
/// Cannot be null (Nothing in Visual Basic).</param>
/// <param name="stream">The stream, where the image should be
/// decoded from. Cannot be null (Nothing in Visual Basic).</param>
/// <exception cref="System.ArgumentNullException">
/// <para><paramref name="image"/> is null (Nothing in Visual Basic).</para>
/// <para>- or -</para>
/// <para><paramref name="stream"/> is null (Nothing in Visual Basic).</para>
/// </exception>
public void Decode(ExtendedImage image, Stream stream)
{
Guard.NotNull(image, "image");
Guard.NotNull(stream, "stream");
if (UseLegacyLibrary)
{
FluxCoreJpegDecoder fluxCoreJpegDecoder = new FluxCoreJpegDecoder(stream);
DecodedJpeg jpg = fluxCoreJpegDecoder.Decode();
jpg.Image.ChangeColorSpace(ColorSpace.RGB);
int pixelWidth = jpg.Image.Width;
int pixelHeight = jpg.Image.Height;
byte[] pixels = new byte[pixelWidth * pixelHeight * 4];
byte[][,] sourcePixels = jpg.Image.Raster;
for (int y = 0; y < pixelHeight; y++)
{
for (int x = 0; x < pixelWidth; x++)
{
int offset = (y * pixelWidth + x) * 4;
pixels[offset + 0] = sourcePixels[0][x, y];
pixels[offset + 1] = sourcePixels[1][x, y];
pixels[offset + 2] = sourcePixels[2][x, y];
pixels[offset + 3] = (byte)255;
}
}
//-------
image.DensityXInt32 = jpg.Image.DensityX;
image.DensityYInt32 = jpg.Image.DensityY;
image.SetPixels(pixelWidth, pixelHeight, pixels);
}
else
{
JpegImage jpg = new JpegImage(stream);
int pixelWidth = jpg.Width;
int pixelHeight = jpg.Height;
byte[] pixels = new byte[pixelWidth * pixelHeight * 4];
if (!(jpg.Colorspace == Colorspace.RGB && jpg.BitsPerComponent == 8))
{
throw new UnsupportedImageFormatException();
}
for (int y = 0; y < pixelHeight; y++)
{
SampleRow row = jpg.GetRow(y);
for (int x = 0; x < pixelWidth; x++)
{
//Sample sample = row.GetAt(x);
int offset = (y * pixelWidth + x) * 4;
row.GetComponentsAt(x, out pixels[offset + 0], out pixels[offset + 1], out pixels[offset + 2]);
//r = (byte)sample[0];
//g = (byte)sample[1];
//b = (byte)sample[2];
//pixels[offset + 0] = r;
//pixels[offset + 1] = g;
//pixels[offset + 2] = b;
pixels[offset + 3] = (byte)255;
}
}
image.SetPixels(pixelWidth, pixelHeight, pixels);
}
}
