private byte[] GetImageBin(CaptureData captureData, byte[] binData)
{
if (binData == null)
{
return(null);
}
switch (captureData.compress)
{
#if UNITY_EDITOR
case TextureCompress.None:
return(ImageConversion.EncodeArrayToPNG(binData,
UnityEngine.Experimental.Rendering.GraphicsFormat.R8G8B8A8_SRGB,
(uint)captureData.width, (uint)captureData.height));
case TextureCompress.RGB_565:
return(ImageConversion.EncodeArrayToPNG(binData,
UnityEngine.Experimental.Rendering.GraphicsFormat.R5G6B5_UNormPack16,
(uint)captureData.width, (uint)captureData.height));
#endif
case TextureCompress.PNG:
case TextureCompress.JPG_BufferRGB565:
case TextureCompress.JPG_BufferRGBA:
return(binData);
}
return(null);
}
/// <summary>
/// Encode the input data as per provided image format.
/// </summary>
/// <param name="data">An array of data to be encoded.</param>
/// <param name="width">Image width.</param>
/// <param name="height">Image height.</param>
/// <param name="format">Graphics format used by the render texture.</param>
/// <param name="imageFormat">Format for encoding the data.</param>
/// <param name="additionalParam">Additional flags to be passed for the encoding.</param>
/// <returns></returns>
/// <exception cref="NotSupportedException"></exception>
public static Array EncodeArray(Array data, int width, int height, GraphicsFormat format, ImageFormat imageFormat, int additionalParam = 0)
{
switch (imageFormat)
{
case ImageFormat.Raw:
return(data);
#if UNITY_2019_3_OR_NEWER
case ImageFormat.Png:
return(ImageConversion.EncodeArrayToPNG(data, format, (uint)width, (uint)height, 0));
case ImageFormat.Exr:
return(ImageConversion.EncodeArrayToEXR(data, format, (uint)width, (uint)height, 0, /*EXRFlags*/ (Texture2D.EXRFlags)additionalParam));
case ImageFormat.Tga:
return(ImageConversion.EncodeArrayToTGA(data, format, (uint)width, (uint)height, 0));
#endif
case ImageFormat.Jpg:
#if USIM_USE_BUILTIN_JPG_ENCODER
return(ImageConversion.EncodeArrayToJPG(data, format, (uint)width, (uint)height, 0, /*quality*/ additionalParam > 0 ? (int)additionalParam : 75));
#else
return(JpegEncoder.Encode(ArrayUtilities.Cast <byte>(data), width, height, GraphicsUtilities.GetBlockSize(format), format, /*quality*/ additionalParam > 0 ? (int)additionalParam : 75));
#endif
default:
throw new NotSupportedException("ImageFormat is not supported");
}
}
private byte[] encodeFrame(uint[] rawData)
{
var data = ImageConversion.EncodeArrayToPNG(rawData, GraphicsFormat.R8G8B8_UNorm, IMAGE_WIDTH, IMAGE_HEIGHT);
if (data.Length > 65535)
{
throw new Exception("Max image size exceeded");
}
byte lowerByte = (byte)(data.Length & 0xff);
byte higherByte = (byte)((data.Length & 0xff00) >> 8);
//Debug.Log("Length " + data.Length + " " + higherByte + " " + lowerByte);
byte[] lengthAsBytes = new byte[] { higherByte, lowerByte };
byte[] encodedBytes = lengthAsBytes.Concat(data).ToArray();
return(encodedBytes);
}
void CaptureRgbData(Camera cam)
{
Profiler.BeginSample("CaptureDataFromLastFrame");
if (!captureRgbImages)
{
return;
}
var captureFilename = Path.Combine(Manager.Instance.GetDirectoryFor(RgbDirectory), $"{s_RgbFilePrefix}{Time.frameCount}.png");
var dxRootPath = Path.Combine(RgbDirectory, $"{s_RgbFilePrefix}{Time.frameCount}.png");
SensorHandle.ReportCapture(dxRootPath, SensorSpatialData.FromGameObjects(m_EgoMarker == null ? null : m_EgoMarker.gameObject, gameObject), m_PersistentSensorData.Select(kvp => (kvp.Key, kvp.Value)).ToArray());
Func <AsyncRequest <CaptureCamera.CaptureState>, AsyncRequest.Result> colorFunctor;
var width = cam.pixelWidth;
var height = cam.pixelHeight;
var flipY = ShouldFlipY(cam);
colorFunctor = r =>
{
using (s_WriteFrame.Auto())
{
var dataColorBuffer = (byte[])r.data.colorBuffer;
if (flipY)
{
FlipImageY(dataColorBuffer, height);
}
byte[] encodedData;
using (s_EncodeAndSave.Auto())
{
encodedData = ImageConversion.EncodeArrayToPNG(dataColorBuffer, GraphicsFormat.R8G8B8A8_UNorm, (uint)width, (uint)height);
}
return(!FileProducer.Write(captureFilename, encodedData) ? AsyncRequest.Result.Error : AsyncRequest.Result.Completed);
}
};
CaptureCamera.Capture(cam, colorFunctor);
Profiler.EndSample();
}
// execute data
private void ExecuteBinData(CaptureData captureData, byte[] binData)
{
this.InitDirectory();
string file = GetFilePath(captureData);
byte[] pngBin = null;
#if UNITY_EDITOR
pngBin = ImageConversion.EncodeArrayToPNG(binData,
UnityEngine.Experimental.Rendering.GraphicsFormat.R8G8B8A8_SRGB,
(uint)captureData.width, (uint)captureData.height);
// debug!
// File.WriteAllBytes(file.Replace("png", "bin"), binData);
#endif
if (pngBin != null)
{
File.WriteAllBytes(file, pngBin);
}
}
void OnSemanticSegmentationImageRead(int frameCount, NativeArray <Color32> data)
{
if (!m_AsyncAnnotations.TryGetValue(frameCount, out var annotation))
{
return;
}
var datasetRelativePath = $"{k_SemanticSegmentationDirectory}/{k_SegmentationFilePrefix}{frameCount}.png";
var localPath = $"{Manager.Instance.GetDirectoryFor(k_SemanticSegmentationDirectory)}/{k_SegmentationFilePrefix}{frameCount}.png";
annotation.ReportFile(datasetRelativePath);
var asyncRequest = Manager.Instance.CreateRequest <AsyncRequest <AsyncSemanticSegmentationWrite> >();
imageReadback?.Invoke(new ImageReadbackEventArgs
{
data = data,
frameCount = frameCount,
sourceTexture = targetTexture
});
asyncRequest.data = new AsyncSemanticSegmentationWrite
{
data = new NativeArray <Color32>(data, Allocator.TempJob),
width = targetTexture.width,
height = targetTexture.height,
path = localPath
};
asyncRequest.Enqueue((r) =>
{
Profiler.BeginSample("Encode");
var pngBytes = ImageConversion.EncodeArrayToPNG(r.data.data.ToArray(), GraphicsFormat.R8G8B8A8_UNorm, (uint)r.data.width, (uint)r.data.height);
Profiler.EndSample();
Profiler.BeginSample("WritePng");
File.WriteAllBytes(r.data.path, pngBytes);
Manager.Instance.ConsumerFileProduced(r.data.path);
Profiler.EndSample();
r.data.data.Dispose();
return(AsyncRequest.Result.Completed);
});
asyncRequest.Execute();
}
async UniTask ShootAsync()
{
var rt = mycamera.targetTexture;
var req = await AsyncGPUReadback.Request(rt, 0);
Debug.Log("GPU Readback done?:" + req.done);
var rawByteArray = req.GetData <byte>().ToArray();
var graphicsFormat = rt.graphicsFormat;
var width = (uint)rt.width;
var height = (uint)rt.height;
Debug.Log("BytesSize:" + rawByteArray.Length);
var imageBytes = ImageConversion.EncodeArrayToPNG(rawByteArray, graphicsFormat, width, height);
File.WriteAllBytes("my_screenshot.png", imageBytes); // test
}
// Build voxel object
public override float Build(Storage voxels, Bounds bounds, Informer informer, object parameter)
{
processor.superSamplingCount = superSamplingCount;
processor.powerOfTwo = powerOfTwo;
processor.expandEdges = expandEdges;
processor.backgroundColor = backgroundColor;
processor.hdr = fileFormat == FileFormat.EXR;
// Execute real build-up method
float progress = processor.Build(voxels, bounds);
// Check if processing has been finished
if (progress >= 1)
{
// Store file, if it is specified
if (fileStoring && filePath != null && filePath.Length > 0 && Texture != null)
{
try
{
// Build target path
switch (fileFormat)
{
#if UNITY_2020_2_OR_NEWER
case FileFormat.JPG:
case FileFormat.PNG:
case FileFormat.TGA:
case FileFormat.EXR:
var source = processor.Texture;
if (source)
{
var sourceData = source.GetPixelData <byte>(0);
if (sourceData != null)
{
var length = source.width * source.height * source.depth;
//var textureWidth = Mathf.CeilToInt(Mathf.Sqrt(length));
var textureWidth = (int)Math.Pow(2, Math.Ceiling(Math.Log(Mathf.Sqrt(length)) / Math.Log(2)));
var columnsCount = Mathf.CeilToInt((float)textureWidth / source.width);
var rowsCount = Mathf.CeilToInt((float)source.depth / columnsCount);
textureWidth = source.width * columnsCount;
var textureHeight = source.height * rowsCount;
var pixelSize = processor.hdr ? 8 : 4;
var lineSize = source.width * pixelSize;
var buffer = new byte[lineSize];
var targetData = new byte[textureWidth * textureHeight * pixelSize];
if (targetData != null)
{
var sourceOffset = 0;
// Process depth slices
for (int slice = 0; slice < source.depth; ++slice)
{
// Calculate column and row of the target sub image
var column = slice % columnsCount;
var row = rowsCount - slice / columnsCount - 1;
// Process lines of the current slice
for (int line = 0; line < source.height; ++line)
{
// Get data for line into the cache
sourceData.GetSubArray(sourceOffset, lineSize).CopyTo(buffer);
// Copy it to the target buffer
Array.Copy(buffer, 0, targetData, (column + (line + row * source.height) * columnsCount) * lineSize, lineSize);
sourceOffset += lineSize;
}
}
byte[] data;
switch (fileFormat)
{
case FileFormat.JPG:
// Convert image data to JPEG data
data = ImageConversion.EncodeArrayToJPG(targetData, source.graphicsFormat, (uint)textureWidth, (uint)textureHeight, 0, 100);
break;
case FileFormat.PNG:
// Convert image data to PNG data
data = ImageConversion.EncodeArrayToPNG(targetData, source.graphicsFormat, (uint)textureWidth, (uint)textureHeight);
break;
case FileFormat.TGA:
// Convert image data to TGA data
data = ImageConversion.EncodeArrayToTGA(targetData, source.graphicsFormat, (uint)textureWidth, (uint)textureHeight);
break;
case FileFormat.EXR:
// Convert image data to EXR data
data = ImageConversion.EncodeArrayToEXR(targetData, source.graphicsFormat, (uint)textureWidth, (uint)textureHeight, 0, UnityEngine.Texture2D.EXRFlags.CompressZIP);
break;
default:
data = null;
break;
}
if (data != null)
{
// Make sure the target folders exist
var path = System.IO.Path.Combine(Application.dataPath, filePath);
if (Helper.CreateDirectory(path, true))
{
#if UNITY_EDITOR
// Remove existing asset file
if (System.IO.File.Exists(path))
{
System.IO.File.Delete(path);
}
// Update database
UnityEditor.AssetDatabase.Refresh();
#endif
// Save data to file
System.IO.File.WriteAllBytes(path, data);
#if UNITY_EDITOR
// Store columns and rows for the asset to be applied later
voxelTexturePaths.Add(System.IO.Path.GetFullPath(path), new Vector2Int(columnsCount, rowsCount));
// Update database to enable changing import settings
UnityEditor.AssetDatabase.Refresh();
#endif
}
}
}
}
}
break;
#endif
default:
// Save texture as asset file
Helper.StoreAsset(processor.Texture, filePath, null);
break;
}
}
catch (System.Exception exception)
{
Debug.Log(exception.Message);
}
}
#if UNITY_EDITOR
// Add object creation undo operation
if (!Application.isPlaying)
{
UnityEditor.Undo.RegisterCreatedObjectUndo(processor.Texture, "\"VoxelTexture3D\" Creation");
}
#endif
// Execute informer callback
informer?.Invoke(new UnityEngine.Object[] { processor.Texture }, parameter);
}
return(progress);
}