/// <summary>
/// Increment the pixel count and add to the color information
/// </summary>
public void Increment(Color32 *pixel)
{
this._pixelCount++;
this._red += pixel->Red;
this._green += pixel->Green;
this._blue += pixel->Blue;
}
public unsafe void Execute(int index)
{
Color32 *outputColor = (Color32 *)output[index];
for (int i = flattenIndex[index].start; i <= flattenIndex[index].end; ++i)
{
if (original[i] == IntPtr.Zero)
{
continue;
}
Color32 *originalColor = (Color32 *)original[i];
int bufferWidth = width[i];
int bufferHeight = height[i];
for (int h = 0; h < bufferHeight; ++h)
{
int originalYOffset = h * bufferWidth;
int outputYOffset = (bufferHeight - h - 1) * bufferWidth;
for (int w = 0; w < bufferWidth; ++w)
{
var outColor = outputColor[w + outputYOffset];
var inColor = originalColor[w + originalYOffset];
float alpha = outColor.a / 255.0f;
outColor.r = (byte)(alpha * (float)(outColor.r) + (float)((1.0f - alpha) * (float)inColor.r));
outColor.g = (byte)(alpha * (float)(outColor.g) + (float)((1.0f - alpha) * (float)inColor.g));
outColor.b = (byte)(alpha * (float)(outColor.b) + (float)((1.0f - alpha) * (float)inColor.b));
outColor.a = (byte)(alpha * (float)(outColor.a) + (float)((1.0f - alpha) * (float)inColor.a));
outputColor[w + outputYOffset] = outColor;
}
}
}
}
private static void CopyFullRow(Color32 *dst, Color32 *src)
{
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
dst[3] = src[3];
}
public static void LoadFont(string fontPath)
{
var surf = SDL_image.IMG_Load(fontPath);
if (surf == IntPtr.Zero)
{
Console.WriteLine("Font loading failed, things about to break");
Console.WriteLine(SDL_image.IMG_GetError());
return;
}
var fontSurface = Marshal.PtrToStructure <SDL.SDL_Surface>(surf);
fontWidth = fontSurface.w;
fontHeight = fontSurface.h;
fontBuffer = new bool[fontWidth, fontHeight];
unsafe {
Color32 *colors = (Color32 *)fontSurface.pixels;
for (int i = 0; i < fontWidth; i++)
{
for (int j = 0; j < fontHeight; j++)
{
int fontColorBufferIndex = (j * fontWidth) + i;
fontBuffer[i, fontHeight - j - 1] = colors[fontColorBufferIndex].r > 0;
}
}
}
fontWidth = fontSurface.w / 16;
fontHeight = fontSurface.h / 8;
}
public unsafe static extern void CalibrateCamera(
Color32 *textureData, int width, int height,
IntPtr image_points,
IntPtr object_points,
IntPtr cameraMatrix,
IntPtr distortionCoefficients
);
/// <summary> Increment the pixel count and add to the color information. </summary>
public void Increment(Color32 *pixel)
{
pixelCount++;
red += pixel->Red;
green += pixel->Green;
blue += pixel->Blue;
}
/// <summary>
/// Override this to process the pixel in the second pass of the algorithm
/// </summary>
/// <param name="pixel">The pixel to quantize</param>
/// <param name="destinationPixel"></param>
/// <returns>The quantized value</returns>
protected override void QuantizePixel(Color32 *pixel, Color32 *destinationPixel)
{
int maxColor = pixel->Red;
if (maxColor < pixel->Green)
{
maxColor = pixel->Green;
}
if (maxColor < pixel->Blue)
{
maxColor = pixel->Blue;
}
int minColor = pixel->Red;
if (minColor > pixel->Green)
{
minColor = pixel->Green;
}
if (minColor > pixel->Blue)
{
minColor = pixel->Blue;
}
var luminance = (byte)((minColor + maxColor) / 2.00f);
destinationPixel->Red = luminance;
destinationPixel->Green = luminance;
destinationPixel->Blue = luminance;
destinationPixel->Alpha = pixel->Alpha;
}
protected override unsafe void Map(Color32 *pixels, int len)
{
for (int ii = 0; ii < len; ++ii)
{
Color32 pixel = pixels[ii];
if (pixel.a > zero)
{
float value = pixel.r / 255f;
if (value > 0.5f)
{
value = value * 2 - 1f;
pixel.r = (byte)(mGray.r + value * (mWhite.r - mGray.r));
pixel.g = (byte)(mGray.g + value * (mWhite.g - mGray.g));
pixel.b = (byte)(mGray.b + value * (mWhite.b - mGray.b));
}
else
{
value = value * 2;
pixel.r = (byte)(mBlack.r + value * (mGray.r - mBlack.r));
pixel.g = (byte)(mBlack.g + value * (mGray.g - mBlack.g));
pixel.b = (byte)(mBlack.b + value * (mGray.b - mBlack.b));
}
pixels[ii] = pixel;
}
}
}
/// <summary>
/// Override this to process the pixel in the second pass of the algorithm
/// </summary>
/// <param name="pixel">The pixel to quantize</param>
/// <param name="destinationPixel"></param>
/// <returns>The quantized value</returns>
protected override void QuantizePixel(Color32 *pixel, Color32 *destinationPixel)
{
destinationPixel->Red = pixel->Alpha;
destinationPixel->Blue = pixel->Alpha;
destinationPixel->Green = pixel->Alpha;
destinationPixel->Alpha = 255;
}
/// <summary>
/// Increment the pixel count and add to the color information
/// </summary>
/// <param name="pixel">
/// The pixel to add.
/// </param>
public void Increment(Color32 *pixel)
{
this.pixelCount++;
this.red += pixel->R;
this.green += pixel->G;
this.blue += pixel->B;
}
public void Increment(Color32 *pixel)
{
Red += pixel->Red;
Green += pixel->Green;
Blue += pixel->Blue;
PixelCount++;
}
private static Color32[] FromSRGBOrSRGBA(IntPtr ptr, ImageFormat format, int width, int height, int widthStep)
{
var colors = new Color32[width * height];
var padding = format == ImageFormat.SRGB ? (widthStep - 3 * width) : (widthStep - 4 * width);
unsafe
{
fixed(Color32 *dest = colors)
{
byte * pSrc = (byte *)ptr.ToPointer();
Color32 *pDest = dest;
for (var i = 0; i < height; i++)
{
for (var j = 0; j < width; j++)
{
byte r = *pSrc++;
byte g = *pSrc++;
byte b = *pSrc++;
byte a = format == ImageFormat.SRGB ? (byte)255 : (*pSrc++);
* pDest++ = new Color32(r, g, b, a);
}
pSrc += padding;
}
}
}
return(colors);
}
public void CaptureFrame(Color32[] pixelBuffer)
{
if (preview == null)
{
return;
}
#if OPENCV_USE_UNSAFE_CODE && UNITY_2018_2_OR_NEWER
unsafe
{
NativeArray <Color32> rawTextureData = preview.GetRawTextureData <Color32>();
int size = UnsafeUtility.SizeOf <Color32>() * rawTextureData.Length;
Color32 *srcAddr = (Color32 *)NativeArrayUnsafeUtility.GetUnsafeReadOnlyPtr(rawTextureData);
fixed(Color32 *dstAddr = pixelBuffer)
{
UnsafeUtility.MemCpy(dstAddr, srcAddr, size);
}
}
#else
byte[] rawTextureData = preview.GetRawTextureData();
GCHandle pin = GCHandle.Alloc(pixelBuffer, GCHandleType.Pinned);
Marshal.Copy(rawTextureData, 0, pin.AddrOfPinnedObject(), rawTextureData.Length);
pin.Free();
#endif
}
public void Draw(Texture2D texture, ImageFrame mask, Color color, bool isFlipped = false, float threshold = 0.9f)
{
var maskPixels = mask.GetColor32s(isFlipped);
var maskWidth = mask.Width();
var maskHeight = mask.Height();
var minValue = 255 * threshold;
unsafe
{
fixed(Color32 *maskPtr = maskPixels)
{
Color32 *pixel = maskPtr;
for (var i = 0; i < maskHeight; i++)
{
for (var j = 0; j < maskWidth; j++)
{
if (pixel->r > minValue)
{
SetMask(texture, j, i, maskWidth, maskHeight, (float)(pixel->r) / 255, color);
}
pixel++;
}
}
}
}
}
/// <summary>
/// Increment the pixel count and add to the color information
/// </summary>
/// <param name="pixel">
/// The pixel to add.
/// </param>
public void Increment(Color32 *pixel)
{
pixelCount++;
red += pixel->R;
green += pixel->G;
blue += pixel->B;
}
public unsafe void Increment(Color32 *pixel)
{
_pixelCount++;
_red += pixel->Red;
_green += pixel->Green;
_blue += pixel->Blue;
}
public static void stb_compress_dxt_block(byte *dest, Color32 *src, int alpha, int mode)
{
var data = stackalloc Color32[16];
if (init != 0)
{
stb__InitDXT();
init = 0;
}
if (alpha != 0)
{
var i = 0;
stb__CompressAlphaBlock(dest, src);
dest += 8;
for (i = 0; i < 16; ++i)
{
data[i] = src[i];
data[i].a = 255;
}
src = data;
}
stb__CompressColorBlock(dest, src, mode);
}
/// <summary> Add a color into the tree. </summary>
/// <param name="pixel"> The color. </param>
/// <param name="colorBits"> The number of significant color bits. </param>
/// <param name="level"> The level in the tree. </param>
/// <param name="octree"> The tree to which this node belongs. </param>
public void AddColor(Color32 *pixel, int colorBits, int level, Octree octree)
{
// Update the color information if this is a leaf
if (leaf)
{
Increment(pixel);
// Setup the previous node
octree.TrackPrevious(this);
}
else
{
// Go to the next level down in the tree
int shift = 7 - level;
int index = ((pixel->Red & Mask[level]) >> (shift - 2)) |
((pixel->Green & Mask[level]) >> (shift - 1)) |
((pixel->Blue & Mask[level]) >> (shift));
OctreeNode child = children[index];
if (null == child)
{
// Create a new child node & store in the array
child = new OctreeNode(level + 1, colorBits, octree);
children[index] = child;
}
// Add the color to the child node
child.AddColor(pixel, colorBits, level + 1, octree);
}
}
private unsafe byte QuantizePixel(Color32 *pixel)
{
byte colorIndex = 0;
int colorHash = pixel->ARGB;
if (_colorMap.ContainsKey(colorHash))
{
colorIndex = (byte)_colorMap[colorHash];
}
else
{
if (0 == pixel->Alpha)
{
for (int index = 0; index < _colors.Length; index++)
{
if (0 == _colors[index].A)
{
colorIndex = (byte)index;
break;
}
}
}
else
{
int leastDistance = int.MaxValue;
int red = pixel->Red;
int green = pixel->Green;
int blue = pixel->Blue;
for (int index = 0; index < _colors.Length; index++)
{
Color paletteColor = _colors[index];
int redDistance = paletteColor.R - red;
int greenDistance = paletteColor.G - green;
int blueDistance = paletteColor.B - blue;
int distance = (redDistance * redDistance) +
(greenDistance * greenDistance) +
(blueDistance * blueDistance);
if (distance < leastDistance)
{
colorIndex = (byte)index;
leastDistance = distance;
if (0 == distance)
{
break;
}
}
}
}
_colorMap.Add(colorHash, colorIndex);
}
return(colorIndex);
}
/// <summary>
/// Override this to process the pixel in the second pass of the algorithm
/// </summary>
/// <param name="pixel">The pixel to quantize</param>
/// <returns>The quantized value</returns>
protected override byte QuantizePixel(Color32 *pixel)
{
byte colorIndex = 0;
int colorHash = pixel->ARGB;
// Check if the color is in the lookup table
if (_colorMap.ContainsKey(colorHash))
{
colorIndex = (byte)_colorMap[colorHash];
}
else
{
// Not found - loop through the palette and find the nearest match.
// Firstly check the alpha value - if < 128, set the transparent color
if (pixel->Alpha < 128)
{
colorIndex = 0; // color 0 is transparent for Freebox
}
else
{
// Not transparent...
int leastDistance = int.MaxValue;
int red = pixel->Red;
int green = pixel->Green;
int blue = pixel->Blue;
// Loop through the freebox palette visible colors, looking for the closest color match
for (int index = 1; index < 192; index++)
{
Color paletteColor = _colors[index];
int redDistance = paletteColor.R - red;
int greenDistance = paletteColor.G - green;
int blueDistance = paletteColor.B - blue;
int distance = (redDistance * redDistance) +
(greenDistance * greenDistance) +
(blueDistance * blueDistance);
if (distance < leastDistance)
{
colorIndex = (byte)index;
leastDistance = distance;
// And if it's an exact match, exit the loop
if (0 == distance)
{
break;
}
}
}
}
// Now I have the color, pop it into the hashtable for next time
_colorMap.Add(colorHash, colorIndex);
}
return(colorIndex);
}
public int width, height; // 2D size (product must be <= length)
// no allocation; pointer comes from a []
public ColorBuffer(Color32[] c, Color32 *pc, int width_, int height_)
{
width = width_;
height = height_;
length = c.Length;
dealloc = IntPtr.Zero;
array = pc;
}
// allocate non-garbage-collected memory
public ColorBuffer(int width_, int height_)
{
width = width_;
height = height_;
length = width * height;
dealloc = System.Runtime.InteropServices.Marshal.AllocHGlobal(length * sizeof(Color32));
array = (Color32 *)dealloc;
}
public unsafe static extern void FindChessboardCorners(
Color32 *textureData, int width, int height,
int cornersW, int cornersH,
float cornerLength, float cornerSeparation,
IntPtr foundBoardMarkers,
IntPtr image_points,
IntPtr object_points
);
public unsafe void SizeAndAlignmentTest()
{
Assert.AreEqual(4, sizeof(Color32));
Color32 *p = stackalloc Color32[2];
Assert.AreEqual(4, (byte *)&p[1] - (byte *)&p[0]);
}
private unsafe void SetPixelCore(int x, int y, ref WinColor pixelColor)
{
Color32 *pixelPtr = this[x, y];
pixelPtr->A = pixelColor.A;
pixelPtr->R = pixelColor.R;
pixelPtr->G = pixelColor.G;
pixelPtr->B = pixelColor.B;
}
public static void stb__CompressAlphaBlock(byte *dest, Color32 *src)
{
var i = 0;
var dist = 0;
var bias = 0;
var dist4 = 0;
var dist2 = 0;
var bits = 0;
var mask = 0;
var mn = 0;
var mx = 0;
mn = mx = src[0].a;
for (i = 1; i < 16; i++)
{
if (src[i].a < mn)
{
mn = src[i].a;
}
else if (src[i].a > mx)
{
mx = src[i].a;
}
}
dest[0] = (byte)mx;
dest[1] = (byte)mn;
dest += 2;
dist = mx - mn;
dist4 = dist * 4;
dist2 = dist * 2;
bias = dist < 8 ? dist - 1 : dist / 2 + 2;
bias -= mn * 7;
bits = 0;
mask = 0;
for (i = 0; i < 16; i++)
{
var a = src[i].a * 7 + bias;
var ind = 0;
var t = 0;
t = a >= dist4 ? -1 : 0;
ind = t & 4;
a -= dist4 & t;
t = a >= dist2 ? -1 : 0;
ind += t & 2;
a -= dist2 & t;
ind += a >= dist ? 1 : 0;
ind = -ind & 7;
ind ^= 2 > ind ? 1 : 0;
mask |= ind << bits;
if ((bits += 3) >= 8)
{
*dest++ = (byte)mask;
mask >>= 8;
bits -= 8;
}
}
}
/// <summary>
/// Override this to process the pixel in the second pass of the algorithm
/// </summary>
/// <param name="pixel">The pixel to quantize</param>
/// <returns>The quantized value</returns>
protected override byte QuantizePixel(Color32 *pixel)
{
pixel = Quantizer.ConvertAlpha(pixel);
int redIndex = pixel->Red >> 5;
int greenIndex = pixel->Green >> 5;
int blueIndex = pixel->Blue >> 6;
return((byte)((redIndex << 5) + (greenIndex << 2) + blueIndex));
}
public void Deallocate()
{
if (dealloc != IntPtr.Zero)
{
System.Runtime.InteropServices.Marshal.FreeHGlobal(dealloc);
dealloc = IntPtr.Zero;
array = null;
length = width = height = 0;
}
}
protected override unsafe byte QuantizePixel(Color32 *pixel)
{
var paletteIndex = (byte)_maxColors;
if (pixel->Alpha > 254)
{
paletteIndex = (byte)_octree.GetPaletteIndex(pixel);
}
return(paletteIndex);
}
/// <summary> Override this to process the pixel in the second pass of the algorithm. </summary>
/// <param name="pixel"> The pixel to quantize. </param>
/// <returns> The quantized value. </returns>
protected override byte QuantizePixel(Color32 *pixel)
{
byte paletteIndex = (byte)maxColors; // The color at [_maxColors] is set to transparent
// Get the palette index if this non-transparent
if (pixel->Alpha > 0)
{
paletteIndex = (byte)octree.GetPaletteIndex(pixel);
}
return(paletteIndex);
}
