public static Boolean TexturesCollide(Color[,] texture1, Matrix matrix1, Color[,] texture2, Matrix matrix2)
{
Matrix mat1to2 = matrix1 * Matrix.Invert(matrix2);
Int32 width1 = texture1.GetLength(0);
Int32 height1 = texture1.GetLength(1);
Int32 width2 = texture2.GetLength(0);
Int32 height2 = texture2.GetLength(1);
for (Int32 x1 = 0; x1 < width1; x1++) {
for (Int32 y1 = 0; y1 < height1; y1++) {
Vector2 pos1 = new Vector2(x1, y1);
Vector2 pos2 = Vector2.Transform(pos1, mat1to2);
Int32 x2 = (Int32)pos2.X;
Int32 y2 = (Int32)pos2.Y;
if ((x2 >= 0) && (x2 < width2)) {
if ((y2 >= 0) && (y2 < height2)) {
if (texture1[x1, y1].A > 0) {
if (texture2[x2, y2].A > 0) {
return true;
}
}
}
}
}
}
return false;
}
public Color interpolation(Color[,] original_Buffer, PointF p)
{
int x1 = (int)Math.Floor(p.X),
y1 = (int)Math.Floor(p.Y),
x2 = x1 + 1,
y2 = y1 + 1;
x1 = OutBoundery(x1, original_Buffer.GetLength(0));
x2 = OutBoundery(x2, original_Buffer.GetLength(0));
y1 = OutBoundery(y1, original_Buffer.GetLength(1));
y2 = OutBoundery(y2, original_Buffer.GetLength(1));
Color p1 = original_Buffer[x1, y1];
Color p2 = original_Buffer[x2, y1];
Color p3 = original_Buffer[x1, y2];
Color p4 = original_Buffer[x2, y2];
double Xfraction = p.X - x1;
double Yfraction = p.Y - y1;
//interpolate in X_Direction
Data dataX1, dataX2, dataFinal;
dataX1 = interpolate(p1, p2, Xfraction);
dataX2 = interpolate(p3, p4, Xfraction);
//interpolate in Y_Direction
Color newX1 = Color.FromArgb((int)dataX1.R_Val, (int)dataX1.G_Val, (int)dataX1.B_Val);
Color newX2 = Color.FromArgb((int)dataX2.R_Val, (int)dataX2.G_Val, (int)dataX2.B_Val);
dataFinal = interpolate(newX1, newX2, Yfraction);
return Color.FromArgb((int)(dataFinal.R_Val), (int)(dataFinal.G_Val), (int)(dataFinal.B_Val));
}
public static Color[,] InterpolateHeight(Color[,] img, int height)
{
if (height == img.GetLength(1))
{
return(img);
}
Color[,] nMatrix = new Color[img.GetLength(0), height];
for (int i = 0; i < img.GetLength(0); i++)
{
Point lastIndex = new Point(0, 0);
for (int j = 0; j < img.GetLength(1); j++)
{
double percentY = (double)j / (double)img.GetLength(1);
int nY = (int)Math.Round(((double)nMatrix.GetLength(1) * (double)percentY));
if (nY >= nMatrix.GetLength(1))
{
nY = nMatrix.GetLength(1) - 1;
}
nMatrix[i, nY] = img[i, j];
for (int tY = lastIndex.Y + 1; tY < nY; tY++)
{
float time = (float)tY / (float)nY;
nMatrix[i, tY] = PixelTransform.InterpolateColor(nMatrix[lastIndex.X, lastIndex.Y], nMatrix[i, nY], time);
}
lastIndex = new Point(i, nY);
}
}
return(nMatrix);
}
public Bitmap Create(Color[,] data)
{
int width = data.GetLength(0);
int height = data.GetLength(1);
Bitmap bitmap = new Bitmap(width, height, PixelFormat.Format24bppRgb);
BitmapData bmData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadWrite, bitmap.PixelFormat);
int stride = bmData.Stride;
byte[] array = new byte[stride * height];
int index = 0;
for (int y = height - 1; y >= 0; y--)
{
for (int x = 0; x < width; x++)
{
array[index++] = data[x, y].B;
array[index++] = data[x, y].G;
array[index++] = data[x, y].R;
}
}
IntPtr scan0 = bmData.Scan0;
Marshal.Copy(array, 0, scan0, stride * bitmap.Height);
bitmap.UnlockBits(bmData);
return bitmap;
}
public Color[,] RenderEffect(Color[,] buffer, Color[] palette, int eventToRender)
{
var colorCount = palette.Length;
var spiralCount = colorCount * tbPaletteRepeat.Value;
var bufferHeight = buffer.GetLength(Utils.IndexRowsOrHeight);
var bufferWidth = buffer.GetLength(Utils.IndexColsOrWidth);
var deltaStrands = bufferWidth / spiralCount;
var spiralThickness = (deltaStrands * tbThickness.Value / 100) + 1;
long spiralState = eventToRender * tbDirection.Value;
for (var spiral = 0; spiral < spiralCount; spiral++) {
var strandBase = spiral * deltaStrands;
var color = palette[spiral % colorCount];
for (var thickness = 0; thickness < spiralThickness; thickness++) {
var strand = (strandBase + thickness) % bufferWidth;
for (var row = 0; row < bufferHeight; row++) {
var column = (strand + ((int)spiralState / 10) + (row * tbRotations.Value / bufferHeight)) % bufferWidth;
if (column < 0) {
column += bufferWidth;
}
if (chkBoxBlend.Checked) {
color = palette.GetMultiColorBlend((bufferHeight - row - 1) / (double)bufferHeight, false);
}
if (chkBox3D.Checked) {
var hsv = color.ToHSV();
hsv.Value = (float)((double)(tbRotations.Value < 0 ? thickness + 1 : spiralThickness - thickness) / spiralThickness);
color = hsv.ToColor();
}
buffer[row, column] = color;
}
}
}
return buffer;
}
public static Bitmap CreateIntensityMask(Bitmap bSurface, List <HeatPoint> aHeatPoints, float guc, float yumusat)
{
// Create new graphics surface from memory bitmap
Graphics DrawSurface = Graphics.FromImage(bSurface);
// Set background color to white so that pixels can be correctly colorized
DrawSurface.Clear(Color.White);
// Traverse heat point data and draw masks for each heat point
//foreach (HeatPoint DataPoint in aHeatPoints)
//{
// // Render current heat point on draw surface
// DrawHeatPoint(DrawSurface, DataPoint, 15);
//}
Color[,] vals = new Color[bSurface.Size.Width, bSurface.Size.Height];
System.Threading.Tasks.Parallel.For(0, vals.GetLength(0), x =>
{
System.Threading.Tasks.Parallel.For(0, vals.GetLength(1), y =>
{
vals[x, y] = pointValue(new Point(x, y), guc, yumusat, aHeatPoints);
});
});
for (int x = 0; x < bSurface.Size.Width; x++)
{
for (int y = 0; y < bSurface.Size.Height; y++)
{
DrawSurface.DrawPolygon(new Pen(vals[x, y]), new Point[] { new Point(x, y), new Point(x + 1, y), new Point(x + 1, y + 1), new Point(x, y + 1) });
}
}
return(bSurface);
}
public Color[,] RenderEffect(Color[,] buffer, Color[] palette, int eventToRender)
{
_palette = palette;
_bufferHeight = buffer.GetLength(0);
_bufferWidth = buffer.GetLength(1);
if (eventToRender == 0 || _tempBuf == null) {
InitializeSnowflakes();
}
// move snowflakes
for (var x = 0; x < _bufferWidth; x++) {
var newX = (x + eventToRender / 20) % _bufferWidth; // CW
var newX2 = (x - eventToRender / 20) % _bufferWidth; // CCW
if (newX2 < 0) {
newX2 += _bufferWidth;
}
for (var y = 0; y < _bufferHeight; y++) {
var newY = (y + eventToRender / 10) % _bufferHeight;
var newY2 = (newY + _bufferHeight / 2) % _bufferHeight;
var color1 = GetTempPixel(newX, newY);
if (color1 == Color.Transparent) {
color1 = GetTempPixel(newX2, newY2);
}
buffer[y,x] = color1;
}
}
return buffer;
}
public Color[,] RenderEffect(Color[,] buffer, Color[] palette, int eventToRender)
{
var bufferHeight = buffer.GetLength(Utils.IndexRowsOrHeight);
var bufferWidth = buffer.GetLength(Utils.IndexColsOrWidth);
var random = new Random(chkBoxStrobe.Checked ? DateTime.Now.Millisecond : 2271965);
var steps = tbSteps.Value;
var stepsHalf = steps / 2.0f;
var lights = Convert.ToInt32((bufferHeight * bufferWidth) * (tbLightCount.Value / 100.0));
var step = Math.Max(1, (bufferHeight * bufferWidth) / lights);
for (var y = 0; y < bufferHeight; y++) {
for (var x = 0; x < bufferWidth; x++) {
if ((y * bufferHeight + x + 1) % step != 1 && step != 1) {
continue;
}
var hsv = palette[random.Next() % palette.Length].ToHSV();
var randomStep = (eventToRender + random.Next()) % steps;
hsv.Value = chkBoxStrobe.Checked ? ((randomStep == (int)(stepsHalf + 0.5f)) ? 1.0f : 0.0f) :
Math.Max(0.0f, ((randomStep <= stepsHalf ? randomStep : steps - randomStep) / stepsHalf));
buffer[y, x] = hsv.ToColor();
}
}
return buffer;
}
public override Texture2D CreateSprite (Texture2D texture)
{
Color[] pixels = texture.GetPixels ();
Color[,] pixels2D = new Color[texture.width, texture.height];
for (int i = 0; i < pixels.Length; i++) {
int x = i % texture.width;
int y = i / texture.height;
pixels2D [x, y] = pixels [i];
}
int amountOfEyes = (int)(sightAngle / 45);
for (int i = 0; i < amountOfEyes; i++) {
int radius = (texture.width - eyeSize) / 2;
float xPos = Mathf.Sin (Mathf.Deg2Rad * (i * 45));
float yPos = Mathf.Cos (Mathf.Deg2Rad * (i * 45));
Vector2 pos = new Vector2 (xPos, yPos) * radius + new Vector2 (texture.width - eyeSize, texture.height - eyeSize) / 2;
ApplyKernel (ref pixels2D, texture.width, texture.height, pos);
}
for (int x = 0; x < pixels2D.GetLength (0); x++) {
for (int y = 0; y < pixels2D.GetLength (1); y++) {
pixels [x + y * texture.width] = pixels2D [x, y];
}
}
texture.SetPixels (pixels);
texture.Apply ();
return texture;
}
/// <summary>
/// loading the data of a sprite sheet that has a gridline like specified in index
/// </summary>
private void loadSheet()
{
List <SpriteRow> r = new List <SpriteRow>();
SpriteRow CR = new SpriteRow();
Color[,] color = new Color[spriteSheet.Width, spriteSheet.Height];
// puuting all the wanted points inside a list which ill go over later on
color = Tools.getColorMap(spriteSheet);
List <Point> pnt = new List <Point>();
Color refC = color[0, 0];
for (int h = 1; h < color.GetLength(1); h++)
{
for (int w = 0; w < color.GetLength(0); w++)
{
if (color[w, h] == refC)
{
pnt.Add(new Point(w, h));
}
}
}
int firstHight = pnt[0].Y; //height of evet rectangke
int lastHeight = pnt[0].Y; // current row height
int startHight = 0; //height of lasr row
for (int i = 1; i < pnt.Count - 1; i += 2)
{
if (lastHeight != pnt[i].Y)
{
r.Add(CR);
i++;
CR = new SpriteRow();
startHight = lastHeight;
lastHeight = pnt[i].Y;
}
//origin.X = pnt[i].X - pnt[i - 1].X
//origin.Y = lastHeight-startHight
CR.org.Add(new Vector2(pnt[i].X - pnt[i - 1].X, lastHeight - startHight));
//rectangle width = pnt[i + 1].X - pnt[i - 1].X
CR.rec.Add(new Rectangle(pnt[i - 1].X, startHight, pnt[i + 1].X - pnt[i - 1].X, firstHight));
if (CR.rec.Count == (pnt.Count - 1) / 2)
{
r.Add(CR);
}
}
for (int i = 0; i < r.Count(); i++)
{
CR = r[i];
for (int t = 0; t < CR.rec.Count(); t++)
{
this.org.Add(CR.org[t]);
this.rec.Add(CR.rec[t]);
}
}
}
public Color[,] RenderEffect(Color[,] buffer, Color[] palette, int eventToRender)
{
var bufferHeight = buffer.GetLength(Utils.IndexRowsOrHeight);
var bufferWidth = buffer.GetLength(Utils.IndexColsOrWidth);
var colorcnt = palette.Length;
var halfWidth = Math.Max(1, bufferWidth / 2);
var halfHeight = Math.Max(1, bufferHeight / 2);
var outterR = (float) (halfWidth * (tbOuterR.Value / 100.0));
var innerR = (float) (halfWidth * (tbInnerR.Value / 100.0));
if (innerR > outterR) innerR = outterR;
var distance = (float) (halfWidth * (tbDistance.Value / 100.0));
var mod1440 = eventToRender % 1440;
var originalDistance = distance;
for (var i = 1; i <= 360; i++) {
if (chkBoxAnimate.Checked) distance = (int) (originalDistance + eventToRender / 2.0) % 100;
var t = (float) ((i + mod1440) * Math.PI / 180);
var x = Convert.ToInt32((outterR - innerR) * Math.Cos(t) + distance * Math.Cos(((outterR - innerR) / innerR) * t) + halfWidth);
var y = Convert.ToInt32((outterR - innerR) * Math.Sin(t) + distance * Math.Sin(((outterR - innerR) / innerR) * t) + halfHeight);
var x2 = Math.Pow((x - halfWidth), 2);
var y2 = Math.Pow((y - halfHeight), 2);
var hyp = (Math.Sqrt(x2 + y2) / bufferWidth) * 100.0;
if (x >= 0 && x < bufferWidth && y >= 0 && y < bufferHeight) {
buffer[y, x] = palette[(int)(hyp / (colorcnt > 0 ? bufferWidth / colorcnt : 1)) % colorcnt];
}
}
return buffer;
}
private void label3_Click(object sender, EventArgs e)
{
int count = 50;
Image T1 = Bitmap.FromFile("D:\\1.png");
Bitmap TT = new Bitmap(T1);
Random Ran = new Random();
Color[,] Test = new Color[iSize, iSize];
Color[,] TestO = new Color[Test.GetLength(0), Test.GetLength(1)];
for (int i = 0; i < Test.GetLength(0); i++)
{
for (int ii = 0; ii < Test.GetLength(1); ii++)
{
//TestO[i, ii] = Color.FromArgb(Ran.Next(1, 254), Ran.Next(1, 254), Ran.Next(1, 254));
Test[i, ii] = TT.GetPixel(i, ii);
//Test[i, ii] = Color.FromArgb(count+= +Ran.Next(1, 50), count+ Ran.Next(1, 50), count + Ran.Next(1, 50));
if (count >= 154)
{
count = 1;
}
}
}
DateTime DTS = DateTime.Now;
DTS = DateTime.Now;
TestO = myGaussBlur(Test, 5);
//label3.Text += " 算法耗时："+ (DateTime.Now-DTS).ToString();
label3.Refresh();
ImgDrawBefore(Test);
ImgDrawAfter(TestO);
label2.Text = "渲染完成";
label2.Refresh();
}
public override Color[,] apply(Color[,] imageToProcess, MainViewModel reportProgressTo)
{
imageToProcess = base.apply(imageToProcess, reportProgressTo);
for (int i = 0; i < imageToProcess.GetLength(0); i++)
{
int firstPixelY = -1;
for (int j = 0; j < imageToProcess.GetLength(1); j++)
{
if (imageToProcess[i, j].ToArgb() == Color.Black.ToArgb())
if (firstPixelY <= 0 || firstPixelY + 1 == j)
firstPixelY = j;
else
{
for (int k = firstPixelY + 1; k < j; k++)
imageToProcess[i, k] = Color.Black;
firstPixelY = -1;
}
reportProgressTo.Progress++;
}
}
return imageToProcess;
}
public static bool TexturesCollide(Color[,] tex1, Matrix mat1, Color[,] tex2, Matrix mat2)
{
int width1 = tex1.GetLength(0);
int height1 = tex1.GetLength(1);
int width2 = tex2.GetLength(0);
int height2 = tex2.GetLength(1);
Matrix mat1to2 = mat1 * Matrix.Invert(mat2);
for (int x1 = 0; x1 < width1; x1++)
{
for (int y1 = 0; y1 < height1; y1++)
{
Vector2 pos1 = new Vector2(x1, y1);
Vector2 pos2 = Vector2.Transform(pos1, mat1to2);
int x2 = (int)pos2.X;
int y2 = (int)pos2.Y;
if ((x2 < 0) || (x2 >= width2)) continue;
if ((y2 < 0) || (y2 >= height2)) continue;
if (tex1[x1, y1].A <= 0)
{
var tmp = 1 + 1;
var other = tmp + 1;
continue;
}
if (tex2[x2, y2].A <= 0) continue;
// Vector2 screenPos = Vector2.Transform(pos1, mat1);
// return screenPos;
return true;
}
}
// return new Vector2(-1, -1);
return false;
}
/// <summary>
/// Encodes the specified image data to png.
/// </summary>
/// <param name="pixels">
/// The pixel data (bottom line first).
/// </param>
/// <param name="dpi">
/// The image resolution in dots per inch.
/// </param>
/// <returns>
/// The png image data.
/// </returns>
public static byte[] Encode(Color[,] pixels, int dpi = 96)
{
int height = pixels.GetLength(0);
int width = pixels.GetLength(1);
var bytes = new byte[(width * height * 4) + height];
int k = 0;
for (int i = height - 1; i >= 0; i--)
{
bytes[k++] = 0; // Filter
for (int j = 0; j < width; j++)
{
bytes[k++] = pixels[i, j].R;
bytes[k++] = pixels[i, j].G;
bytes[k++] = pixels[i, j].B;
bytes[k++] = pixels[i, j].A;
}
}
var w = new MemoryWriter();
w.Write((byte)0x89);
w.Write("PNG\r\n\x1a\n".ToCharArray());
WriteChunk(w, "IHDR", CreateHeaderData(width, height));
WriteChunk(w, "pHYs", CreatePhysicalDimensionsData(dpi, dpi));
WriteChunk(w, "IDAT", CreateUncompressedBlocks(bytes));
WriteChunk(w, "IEND", new byte[0]);
return w.ToArray();
}
/// <summary>
/// Erode an image using a k by k box kernel
/// </summary>
/// <param name="i">input image</param>
/// <param name="k">kernel thickness</param>
/// <returns>modified image</returns>
public Color[,] Erosion(Color[,] i, int k)
{
//set source image to grayscale
i = PointProcessing.Instance.Treshold(i, 0.5f);
Color[,] result = new Color[i.GetLength(0), i.GetLength(1)];
for (int w = 0 + k; w < i.GetLength(0) - k; w++)
{
for (int h = 0 + k; h < i.GetLength(1) - k; h++)
{
float sum = 0f;
for (int j = -k / 2; j <= +k / 2; j++)
{
for (int l = -k / 2; l <= +k / 2; l++)
{
sum += i[w + j, h + l].r;
}
}
float res = sum < k*k ? 0f : 1f;
result[w, h].r = res;
result[w, h].g = res;
result[w, h].b = res;
}
}
return result;
}
public static Color[,] recolor(int[,] geo)
{
Color[,] geolocal = new Color[geo.GetLength(0), geo.GetLength(1)];
Random rn = new Random();
for (int t1 = 0; t1 < geolocal.GetLength(0) / 20; t1++)
{
for (int t2 = 0; t2 < geolocal.GetLength(1) / 20; t2++)
{
// int currTheme = (rn.Next(3) * 11) + (rn.Next(2) * 38);
// if (currTheme == 2 * 11 || currTheme == 11 + 38)
// break;
double hue = rn.Next(60) - 15;
hue = (Math.Abs(hue * 360) + hue) % 360;
for (int i = 0; i < 20; i++)
{
for (int j = 0; j < 20; j++)
{
if (geo[i + (t1 * 20), j + (t2 * 20)] == gr)
{
geolocal[i + (t1 * 20), j + (t2 * 20)] = Chroma.RandomBlend(Color.White, Color.FromHsv(hue, rn.NextDouble() / 2.5 + 0.2, 0.8), 0.05, 0.2);
}
else if (geo[i + (t1 * 20), j + (t2 * 20)] != da) // && geo[i + (t1 * 20), j + (t2 * 20)] != 1187)
{
geolocal[i + (t1 * 20), j + (t2 * 20)] = Chroma.RandomBlend(Color.White, Color.FromHsv(hue, rn.NextDouble() / 2.5 + 0.2, 0.8), 0.15, 0.3);
}
}
}
}
}
return(geolocal);
}
public static Color[,] InterpolateWidth(Color[,] img, int width)
{
if (width == img.GetLength(0))
{
return(img);
}
Color[,] nMatrix = new Color[width, img.GetLength(1)];
for (int j = 0; j < img.GetLength(1); j++)
{
Point lastIndex = new Point(0, 0);
for (int i = 0; i < img.GetLength(0); i++)
{
double percentX = (double)i / (double)img.GetLength(0);
int nX = (int)Math.Round(((double)nMatrix.GetLength(0) * (double)percentX));
if (nX >= nMatrix.GetLength(0))
{
nX = nMatrix.GetLength(0) - 1;
}
nMatrix[nX, j] = img[i, j];
for (int tX = lastIndex.X + 1; tX < nX; tX++)
{
float time = (float)tX / (float)nX;
nMatrix[tX, j] = PixelTransform.InterpolateColor(nMatrix[lastIndex.X, lastIndex.Y], nMatrix[nX, j], time);
}
lastIndex = new Point(nX, j);
}
}
return(nMatrix);
}
static void DisplayArray(Color[,] array)
{
//Visit each item
for (int row = 0; row < array.GetLength(0); row++)
for (int col = 0; col < array.GetLength(1); col++)
canvas.SetBBScaledPixel(col, row, array[row, col]);
}
public Color[,] RenderEffect(Color[,] buffer, Color[] palette, int eventToRender)
{
const int speedFactor = 200;
var bufferHeight = buffer.GetLength(Utils.IndexRowsOrHeight);
var bufferWidth = buffer.GetLength(Utils.IndexColsOrWidth);
Color color;
var hsv2 = new HSV();
var colorcnt = palette.Length;
var cycleLen = colorcnt * speedFactor;
var count = tbCount.Value;
if (eventToRender > (colorcnt - 1) * speedFactor * count && count < 10) {
color = palette.GetMultiColorBlend(count % 2, false);
} else {
color = palette.GetMultiColorBlend(eventToRender % cycleLen / (double)cycleLen, true);
}
var hsv = color.ToHSV();
var halfHeight = (bufferHeight - 1) / 2.0;
var halfWidth = (bufferWidth - 1) / 2.0;
for (var col = 0; col < bufferWidth; col++) {
for (var row = 0; row < bufferHeight; row++) {
hsv2.SetToHSV(hsv);
if (chkBoxHFade.Checked) hsv2.Value *= (float)(1.0 - Math.Abs(halfWidth - col) / halfWidth);
if (chkBoxVFade.Checked) hsv2.Value *= (float)(1.0 - Math.Abs(halfHeight - row) / halfHeight);
buffer[row, col] = hsv2.ToColor();
}
}
return buffer;
}
public static int[,] ConvertToGreyscale(Color[,] colors, decimal redWeight, decimal greenWeight, decimal blueWeight)
{
int[,] grey = new int[colors.GetLength(0), colors.GetLength(1)];
for (int x = 0; x < colors.GetLength(0); x++)
for (int y = 0; y < colors.GetLength(1); y++)
grey[x, y] = (int)(redWeight * colors[x, y].R + greenWeight * colors[x, y].G + blueWeight * colors[x, y].B);
return grey;
}
public Color[,] RenderEffect(Color[,] buffer, Color[] palette, int eventToRender)
{
var h = 0.0;
var bufferHeight = buffer.GetLength(Utils.IndexRowsOrHeight);
var bufferWidth = buffer.GetLength(Utils.IndexColsOrWidth);
var hsv = new HSV();
var maxframe = bufferHeight*2;
var frame = (int) ((bufferHeight*(double) eventToRender/200.0)%maxframe);
var offset = eventToRender/100.0;
for (var col = 0; col < bufferWidth; col++) {
for (var row = 0; row < bufferHeight; row++) {
double x1;
double y1;
double f;
switch (tbStyle.Value) {
case 1:
var n =
Math.Abs((col*col - row*row)*
Math.Sin(offset + ((col + row)*Pi2/(bufferHeight + bufferWidth))));
var d = col*col + row*row + 1;
h = n/d;
break;
case 2:
f = (frame < maxframe/2) ? frame + 1 : maxframe - frame;
x1 = (col - bufferWidth/2.0)/f;
y1 = (row - bufferHeight/2.0)/f;
h = Math.Sqrt(x1*x1 + y1*y1);
break;
case 3:
f = (frame < maxframe/2) ? frame + 1 : maxframe - frame;
f = f*0.1 + bufferHeight/60.0;
x1 = (col - bufferWidth/2.0)/f;
y1 = (row - bufferHeight/2.0)/f;
h = Math.Sin(x1)*Math.Cos(y1);
break;
}
hsv.Saturation = 1.0f;
hsv.Value = 1.0f;
var chunks = tbChunks.Value;
var skip = tbSkip.Value;
if (chunks > 1 && ((int) (h*chunks))%skip == 0) {
continue;
}
Color color;
if (cbColors.SelectedIndex == 0) {
hsv.Hue = (float) h;
color = hsv.ToColor();
}
else {
color = palette.GetMultiColorBlend(h, false);
}
buffer[row, col] = color;
}
}
return buffer;
}
public override void ReadImage(uint packetID, uint packetSize, BinaryReader br)
{
base.ReadImage(packetID, packetSize, br);
var sw = Stopwatch.StartNew();
bool Is32x32 = false; // true;
switch (packetID)
{
case 27: //1b
case 28: //1c
case 29: //1d (boom beach: in-game_tex.sc & defences_tex.sc)
Is32x32 = true;
break;
}
Console.WriteLine(@"packetID: " + packetID);
Console.WriteLine(@"packetSize: " + packetSize);
Console.WriteLine(@"texPixelFormat: " + _imageType);
Console.WriteLine(@"texWidth: " + _width);
Console.WriteLine(@"texHeight: " + _height);
Console.WriteLine(@"Is32x32: " + Is32x32);
_bitmap = new Bitmap(_width, _height, PixelFormat.Format32bppArgb);
Color[,] pixelArray = new Color[_height, _width];
for (int row = 0; row < pixelArray.GetLength(0); row++)
{
for (int col = 0; col < pixelArray.GetLength(1); col++)
{
ushort color = br.ReadUInt16();
int red = Utils.ConvertMap[(color >> 11) & 0x1F];
int green = Utils.ConvertMap[(color >> 6) & 0x1F];
int blue = Utils.ConvertMap[(color >> 1) & 0x1F];
int alpha = (int)(color & 0x0001) == 1 ? 0xFF : 0x00;
pixelArray[row, col] = Color.FromArgb(alpha, red, green, blue);;
}
}
if (Is32x32)
{
pixelArray = Utils.Solve32X32Blocks(_width, _height, pixelArray);
}
for (int row = 0; row < pixelArray.GetLength(0); row++)
{
for (int col = 0; col < pixelArray.GetLength(1); col++)
{
//Color pxColor = Color.Red;
Color pxColor = pixelArray[row, col];
_bitmap.SetPixel(col, row, pxColor);
}
}
sw.Stop();
Console.WriteLine("ImageRgba5551.ReadImage finished in {0}ms", sw.Elapsed.TotalMilliseconds);
}
public static Color[] ToColorsA(RayTraceChunkManager rtc, int bits)
{
int dcx = rtc.getChunkSize().x;
int dcy = rtc.getChunkSize().y;
int dcz = rtc.getChunkSize().z;
int dgx = rtc.getSizeX();
int dgy = rtc.getSizeY();
int dgz = rtc.getSizeZ();
Color[,,] colors = new Color[dgx, (dgy / bits), dgz];
for (int cx = 0; cx < dcx; cx++)
{
for (int cy = 0; cy < dcy; cy++)
{
for (int cz = 0; cz < dcz; cz++)
{
RayTraceChunk chunk = rtc.getChunk(cx, cy, cz);
for (int bx = 0; bx < Const.ChunkSize; bx++)
{
for (int by = 0; by < Const.ChunkSize / bits; by++)
{
for (int bz = 0; bz < Const.ChunkSize; bz++)
{
int iv = 0;
for (int n = 0; n < bits; n++)
{
iv |= chunk.testBlock(bx, by * bits + n, bz) ? (1 << n) : 0;
}
float a = iv / (float)((1 << bits) - 1);
int gx = cx * Const.ChunkSize + bx;
int gy = cy * Const.ChunkSize / bits + by;
int gz = cz * Const.ChunkSize + bz;
colors[gx, gy, gz] = new Color(0, 0, 0, a);
}
}
}
}
}
}
int sizeX = colors.GetLength(0);
int sizeY = colors.GetLength(1);
int sizeZ = colors.GetLength(2);
Color[] rlt = new Color[sizeX * sizeY * sizeZ];
for (int x = 0; x < sizeX; x++)
{
for (int y = 0; y < sizeY; y++)
{
for (int z = 0; z < sizeZ; z++)
{
rlt[z * sizeY * sizeX + y * sizeX + x] = colors[x, y, z];
}
}
}
return(rlt);
}
public static Color[,] applyFilter(Color[,] screen)
{
// search the screen for the sample
int screen_rows = screen.GetLength(0);
int screen_colums = screen.GetLength(1);
int k = 0;
int l = 0;
Color[,] subImage = new Color[screen_rows, screen_colums];
// Vi itererer over vores sample
while (k < (screen_rows))
{
while (l < (screen_colums))
{
// COPY!
/*int filter = int.Parse("" + screen[i, j].R + screen[i, j].G + screen[i, j].B);
if (filter <= 000)
{*/
Color c = screen[k, l];
if ((int)c.R > 200 || (int)c.G > 200 || (int)c.B > 200)
{
}
else
{
int grayScale = (int)((screen[k, l].R * .3) + (screen[k, l].G * .59) + (screen[k, l].B * .11));
Color newColor = Color.FromArgb(grayScale, grayScale, grayScale);
subImage[k, l] = newColor;
//subImage[k, l] = screen[i, j];
}
/*}*/
if (k == screen_rows - 1 && l == screen_colums - 1)
{
k = screen_rows + 1; // Grimt grimt hack, men vi sparer en goto
break;
}
else if (l == screen_colums - 1)
{
// Hvis vi er for "enden" så reset, og hop til næste row
k++;
l = 0;
// Row jump på screenen også
}
else
{
// Hop en enkelt column både på screen og på sample
l++;
}
}
}
return subImage;
}
public static Bitmap CreateImage(Color[,] values)
{
Bitmap result = new Bitmap(values.GetLength(0), values.GetLength(1));
for (int x = 0; x < result.Width; x++)
for (int y = 0; y < result.Height; y++)
result.SetPixel(x, y, values[x, y]);
return result;
}
public override Color[,] Apply(Color[,] image, int minThreshold = 1)
{
int width = image.GetLength(0);
int height = image.GetLength(1);
int kernelX = this.Size;
int kernelY = this.Size;
int kernelOffsetX = (kernelX - 1) / 2;
int kernelOffsetY = (kernelY - 1) / 2;
Color[,] result = new Color[width, height];
// loop over image coordinates
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
int localMaximum = 0;
if (image[x, y].R < minThreshold) continue;
// loop over neighbourhood pixels
for (int kx = -kernelOffsetX; kx <= kernelOffsetX; kx++)
{
int offsetX = x + kx;
for (int ky = -kernelOffsetY; ky <= kernelOffsetY; ky++)
{
int offsetY = y + ky;
// if not out of bounds
if (!(
offsetX < 0
|| offsetX >= width
|| offsetY < 0
|| offsetY >= height
))
{
//find maximum value
int val = image[offsetX, offsetY].R;
if (val > localMaximum) localMaximum = val;
}
}
}
//if the pixel is the highest in the neighbourhood, keep it on.
if (image[x, y].R == localMaximum)
{
result[x, y] = Color.FromArgb(localMaximum, localMaximum, localMaximum);
}
// otherwise turn the pixel off
else
{
result[x, y] = Color.Black;
}
}
}
return result;
}
public Color <byte>[,] Median3x3Single(Color <byte>[,] imageUnfiltred)
{
string name = "Median3x3Single";
int progress = 2;
int height = imageUnfiltred.GetLength(0);
int width = imageUnfiltred.GetLength(1);
Color <byte>[,] imageFiltred = new Color <byte> [height, width];
for (int i = 1; i < height - 1; i++)
{
Console.WriteLine($"{name}: thread #{Thread.CurrentThread.ManagedThreadId.ToString()} on height {i.ToString()} -> applicating");
for (int j = 1; j < width - 1; j++)
{
Color <int[]> newColors = new Color <int[]>
{
Red = new int[9],
Green = new int[9],
Blue = new int[9]
};
newColors = Convolution(imageUnfiltred, i, j, newColors);
Array.Sort(newColors.Red);
Array.Sort(newColors.Green);
Array.Sort(newColors.Blue);
imageFiltred[i, j].Red = (byte)(newColors.Red[4]);
imageFiltred[i, j].Green = (byte)(newColors.Green[4]);
imageFiltred[i, j].Blue = (byte)(newColors.Blue[4]);
}
progress++;
if (!ProgressCallback(progress, height))
{
Console.WriteLine($"{name}: thread #{Thread.CurrentThread.ManagedThreadId.ToString()} on height {i.ToString()} -> " +
"canceling");
Console.WriteLine($"{name} application has been canceled");
imageUnfiltred = null;
imageFiltred = null;
return(imageFiltred);
}
}
imageUnfiltred = null;
Console.WriteLine($"{name} is succesfully applicated");
return(imageFiltred);
}
public void InitializeComponent()
{
Color[,] colors = new Color[, ] {
{ Color.Black, Color.Gray, Color.Brown, Color.Red, Color.Orange, Color.Yellow, Color.Green, Color.LightBlue, Color.Blue, Color.Violet },
{ Color.White, Color.LightGray, Color.LightCoral, Color.Pink, Color.DarkOrange, Color.LightYellow, Color.GreenYellow, Color.SkyBlue, Color.CadetBlue, Color.Tomato }
};
int magion = DrawingBoardDemo.ColorButtonMagion;
int x = magion + 2;
int y = magion + 2;
int colorButtonSize = DrawingBoardDemo.ColorButtonSize;
foreColorButton = new ColorButton();
foreColorButton.Selected = true;
foreColorButton.Name = "foreColorButton";
foreColorButton.Text = "Fore color";
foreColorButton.Bounds = new Rectangle(x, y, colorButtonSize * 2, colorButtonSize * 2);
foreColorButton.Click += button_Click;
this.Controls.Add(foreColorButton);
x = foreColorButton.Right + magion;
backColorButton = new ColorButton();
backColorButton.Name = "backColorButton";
backColorButton.Text = "Back color";
backColorButton.Bounds = new Rectangle(x, y, colorButtonSize * 2, colorButtonSize * 2);
backColorButton.Click += button_Click;
this.Controls.Add(backColorButton);
x = backColorButton.Right + magion;
int startX = x;
for (int i = 0; i < colors.GetLength(0); i++)
{
x = startX;
for (int j = 0; j < colors.GetLength(1); j++)
{
Button button = new Button();
button.Click += button_Click;
button.Bounds = new Rectangle(x, y, colorButtonSize, colorButtonSize);
button.BackColor = colors[i, j];
x = button.Right + magion;
this.Controls.Add(button);
}
y = y + colorButtonSize + magion;
}
y = magion + 3;
x += 2;
editColorButton = new Button();
editColorButton.Name = "editColorButton";
editColorButton.Text = "Edit colors";
editColorButton.Bounds = new Rectangle(x, y, colorButtonSize * 2, colorButtonSize * 2);
editColorButton.Click += button_Click;
editColorButton.Image = Properties.Resources.ChooseColor;
editColorButton.TextImageRelation = TextImageRelation.ImageAboveText;
this.Controls.Add(editColorButton);
}
public Color[,] ApplyMedian(Color[,] image)
{
int width = image.GetLength(0);
int height = image.GetLength(1);
Color[,] result = new Color[width, height];
int kernelX = this.matrix.GetLength(0);
int kernelY = this.matrix.GetLength(1);
int kernelOffsetX = (kernelX - 1) / 2;
int kernelOffsetY = (kernelY - 1) / 2;
int offsetX, offsetY;
int neighbourhoodSize = kernelX*kernelY;
int[] neighbourhoodValues = new int[neighbourhoodSize];
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
for (int kx = -kernelOffsetX; kx <= kernelOffsetX; kx++)
{
offsetX = x + kx;
for (int ky = -kernelOffsetY; ky <= kernelOffsetY; ky++)
{
offsetY = y + ky;
int row = ky + kernelOffsetY;
int column = kx + kernelOffsetX;
if (
offsetX < 0
|| offsetX >= width
|| offsetY < 0
|| offsetY >= height
)
{
neighbourhoodValues[kernelX * row + column] = this.padding;
}
else
{
neighbourhoodValues[kernelX * row + column] = image[offsetX, offsetY].R;
}
}
}
Array.Sort(neighbourhoodValues);
int median = neighbourhoodValues[(neighbourhoodSize + 1)/2];
result[x, y] = Color.FromArgb(
median, median, median
);
}
}
return result;
}
public Color[,] Render() {
Color[,] c = new Color[BlockEditor.textureSize, BlockEditor.textureSize];
for (int x = 0; x < c.GetLength(0); x++) {
for (int y = 0; y < c.GetLength(1); y++) {
c[x, y] = new Color(heightMap[x, y], heightMap[x, y], heightMap[x, y]);
}
}
return c;
}
private void initializeImageColorTable()
{
currentImageColorTable = new Color[screenPB.Width, screenPB.Height];
for (int i = 0; i < currentImageColorTable.GetLength(0); i++)
{
for (int j = 0; j < currentImageColorTable.GetLength(1); j++)
{
currentImageColorTable[i, j] = textureImageColorTable[i, j];
}
}
}
public Texture2D Array2DToTexture(Color[,] array2D)
{
Color[] colors1D = new Color[array2D.GetLength(0) * array2D.GetLength(1)];
for (int x = 0; x < array2D.GetLength(0); x++)
for (int y = 0; y < array2D.GetLength(1); y++)
colors1D[x + y * array2D.GetLength(0)] = array2D[x, y];
Texture2D texture = new Texture2D(graphics.GraphicsDevice, array2D.GetLength(0), array2D.GetLength(1));
texture.SetData<Color>(colors1D);
return texture;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="symbol">The unicode character.</param>
/// <param name="pixels">The pixels array. Must not be larger than 8x8 pixels.</param>
/// <param name="transparencyColor">The color that represents transparency.</param>
public MultiColorCharacter(char symbol, Color[,] pixels, Color? transparencyColor = null)
: base(symbol, pixels.GetLength(0))
{
if (pixels.GetLength(1) > 8)
{
throw new ArgumentException("The pixels array must not be taller than 8 pixels!");
}
Pixels = pixels;
TransparencyColor = transparencyColor;
}
public SpriteMap(Color[,] pixels)
{
if (((pixels.GetLength(0) % 8) != 0) || ((pixels.GetLength(1) % 8) != 0))
{
throw new ArgumentException("Expecting an image with sides of mutiple of 8 pixels");
}
Pixels = pixels;
SpriteCountHorizontal = Pixels.GetLength(0) / 8;
SpriteCountVertical = Pixels.GetLength(1) / 8;
}
public Color[,] LinearFilter(Color[,] input, double[,] Mask, int originX, int originY, string Postprocessing)
{
int width = input.GetLength(0);
int height = input.GetLength(1);
int mask_width = Mask.GetLength(0);
int mask_height = Mask.GetLength(1);
Color[,] temp = Padding(input, Mask, originX, originY);
Color[,] result = new Color[width, height];
Data[,] data = new Data[width, height];
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
Data sum;
sum.R_Val = sum.G_Val = sum.B_Val = 0;
for (int k = 0; k < mask_height; k++)
{
for (int m = 0; m < mask_width; m++)
{
sum.R_Val += Mask[m, k] * temp[i + m, j + k].R;
sum.G_Val += Mask[m, k] * temp[i + m, j + k].G;
sum.B_Val += Mask[m, k] * temp[i + m, j + k].B;
}
}
if (Postprocessing == "Cutoff")
{
sum.R_Val = pixel.cutOff(sum.R_Val);
sum.G_Val = pixel.cutOff(sum.G_Val);
sum.B_Val = pixel.cutOff(sum.B_Val);
result[i, j] = Color.FromArgb((int)sum.R_Val, (int)sum.G_Val, (int)sum.B_Val);
}
else if (Postprocessing == "Absolute")
{
sum.R_Val = Math.Abs(sum.R_Val);
sum.G_Val = Math.Abs(sum.G_Val);
sum.B_Val = Math.Abs(sum.B_Val);
data[i, j] = sum;
}
else if (Postprocessing == "None")
{
result[i, j] = Color.FromArgb((int)sum.R_Val, (int)sum.G_Val, (int)sum.B_Val);
}
}
}
if (Postprocessing == "Absolute")
{
result = pixel.Contrast(0, 255, data);
}
return result;
}
// Use canvas properties to initialize _aBlockColors, and set each element to the primary color.
// (only used once, so no locks are necessary.)
private void GetNewColorArray()
{
_aBlockColors = new Color[_canvas.ScaledWidth, _canvas.ScaledHeight];
for (int x = 0; x < _aBlockColors.GetLength(0); x++)
{
for (int y = 0; y < _aBlockColors.GetLength(1); y++)
{
_aBlockColors[x, y] = Block._cPrimary;
}
}
ResetState(); // set all blocks with no highlighting initially.
}
Lab[,] RgbArrayToLabArray(Color[,] RgbArray)
{
Lab[,] rawLabArray= new Lab[RgbArray.GetLength(0), RgbArray.GetLength(1)];
for (int i = 0; i < RgbArray.GetLength (0); i++)
{
for (int j = 0; j < RgbArray.GetLength (1); j++)
{
rawLabArray[i,j] = ColorUtil.ConvertRGBtoLAB (RgbArray[i,j]);
}
}
return rawLabArray;
}
private Color[,] GetClusters(double[,] map, int clusterCount, double min = 0, double max = 1)
{
Color[,] cMap = new Color[map.GetLength(0), map.GetLength(1)];
for (int x = 0; x < cMap.GetLength(0); x++)
{
for (int y = 0; y < cMap.GetLength(1); y++)
{
cMap[x, y] = GetClusteredColor(map[x, y], clustersCount, min, max);
}
}
return(cMap);
}
private Color[,] createEmptyBoard()
{
Color[,] array = new Color[10, 20];
for (int i = 0; i < array.GetLength(0); i++)
{
for (int j = 0; j < array.GetLength(1); j++)
{
array[i, j] = new Color(20, 20, 20);
}
}
return(array);
}
private Color[,] GetRangeBlueToRed(double[,] map, double min = 0, double max = 1)
{
Color[,] cMap = new Color[map.GetLength(0), map.GetLength(1)];
for (int x = 0; x < cMap.GetLength(0); x++)
{
for (int y = 0; y < cMap.GetLength(1); y++)
{
cMap[x, y] = GetColor(map[x, y], min, max);
}
}
return(cMap);
}
private static Bitmap CreateBitmapFromColors(Color[,] image)
{
Bitmap bitmap = new Bitmap(image.GetLength(0), image.GetLength(1));
for (int i = 0; i < image.GetLength(0); i++)
{
for (int j = 0; j < image.GetLength(1); j++)
{
bitmap.SetPixel(i, j, image[i, j]);
}
}
return bitmap;
}
/**
* Konstruktor
*/
public BoardEventArgs(Color[,] boardData)
{
Color[,] newBoardData = new Color[boardData.GetLength(0), boardData.GetLength(1)];
for (int i = 0; i < boardData.GetLength(1); i++)
{
for (int j = 0; j < boardData.GetLength(0); j++)
{
newBoardData[j, i] = boardData[j, i];
}
}
removedLines = new List<int>();
this.boardData = newBoardData;
}
/// <summary>
/// Event occurs when the pixel grid needs to be re-painted.
/// </summary>
private void pixelGrid_Paint(object sender, PaintEventArgs e)
{
// Initialize required objects
SyntheticCamera c = new SyntheticCamera(_e, _g, _p, 15, 150, 45.0, 1.0, pixelGrid.Grid.Width, pixelGrid.Grid.Height);
DrawingController drawer = new DrawingController(e.Graphics);
RayTracer ray = new RayTracer(c, 1);
int superWidth = pixelGrid.Grid.Width * ray.ResolutionMultiplier;
int superHeight = pixelGrid.Grid.Height * ray.ResolutionMultiplier;
// Buffer holds the super width and super height colors to eventually avg and render.
Color[,] buffer = new Color[superHeight, superWidth];
// Loop through each pixel and trace a ray through it to find an intersection with the object
Parallel.For(0, superHeight, (y) =>
{
Parallel.For(0, superWidth, (x) =>
{
PointLight pointLight = new PointLight(Color.FromScRgb(1, 1, 1, 1), new Point3D(1000, 1000, 1000));
DirectionalLight sun = new DirectionalLight(Color.FromScRgb(1, 1, 1, 1), new Vector3D(0, 0, -1));
buffer[y, x] = ray.RayTrace(_objects, x, y, pointLight, sun);
});
});
// Calculates the avg's of the super resolution buffer and displys to screen.
for (int i = 0; i < buffer.GetLength(0); i += ray.ResolutionMultiplier)
{
for (int j = 0; j < buffer.GetLength(1); j += ray.ResolutionMultiplier)
{
// Add all the rbg values for each super resolution block of points.
float r = 0, g = 0, b = 0;
for (int m = 0; m < ray.ResolutionMultiplier; ++m)
{
for (int n = 0; n < ray.ResolutionMultiplier; ++n)
{
r += buffer[i + m, j + n].ScR;
g += buffer[i + m, j + n].ScG;
b += buffer[i + m, j + n].ScB;
}
}
// Avg the block of points to 1 pixel
float avgR = (float)(r / Math.Pow(ray.ResolutionMultiplier, 2));
float avgG = (float)(g / Math.Pow(ray.ResolutionMultiplier, 2));
float avgB = (float)(b / Math.Pow(ray.ResolutionMultiplier, 2));
drawer.Color = Color.FromScRgb(1, avgR, avgG, avgB).ToDColor();
drawer.DrawPoint(new System.Drawing.Point(j / ray.ResolutionMultiplier, i / ray.ResolutionMultiplier));
}
}
}
/// <summary>
/// Draws the grid.
/// </summary>
/// <param name="lines">Lines. how many lines you want in the grid</param>
/// <param name="columns">Columns. how many columns you want in the grid</param>
/// <param name="gridLocal">Grid local. The grid being changed.</param>
/// <param name="borderColor">Border color. Im using Unity Color class, basic RGBA style.</param>
public void DrawGrid(int lines,int columns,Color[,] gridLocal, Color borderColor)
{
//I`m going to draw the grid with 4 fors, skipping the grid space to save processing.
//This method can only be used if the background is clear. otherwize it will keep garbage.
//Another way of doing it could be to use 2 fors and if statements inside. It really depends on what we want to do.
//in this drawing method I am cleaning the background each time it changes.
//grid.gridArray = new Color[grid.GridWidth+1, grid.GridHeight+1];
for (int x = 0; x < gridLocal.GetLength(0); x++) {
for (int y = 0; y < gridLocal.GetLength(1); y++) {
gridLocal[x,y] = grid.backgroundColor;
//Debug.Log(gridLocal[x,y]);
}
}
//Getting all first pixels positions of all cells
grid.gridPositions = new Vector2[grid.GridColumns, grid.GridLines];
float rectWidth = (gridLocal.GetLength(0)/columns);
float rectHeigh = (gridLocal.GetLength (1) / lines);
for (int x=0; x < grid.GridColumns; x++) {
for(int y=0; y < grid.GridLines;y++){
grid.gridPositions[x,y] = new Vector2(x*rectWidth,y*rectHeigh);
}
}
//then I paint the lines, pixel by pixel.
for (int x = 0; x < gridLocal.GetLength(0) ; x+=(gridLocal.GetLength(0)/(columns))) {
for (int y = 0; y < gridLocal.GetLength(1) ; y++) {
gridLocal[x,y] = borderColor;
gridLocal[gridLocal.GetLength(0)-1,y] = borderColor;
}
}
for (int x = 0; x < gridLocal.GetLength(0); x++) {
for (int y = 0; y < gridLocal.GetLength(1); y+=(gridLocal.GetLength(1)/lines)) {
gridLocal [x, y] = borderColor;
gridLocal[x,gridLocal.GetLength(1)-1] = borderColor;
}
}
//then I paint the user selected points
Vector2 linePoint = new Vector2 (8, 15);
Vector2 endLinePoint = new Vector2 (60, 104);
for (float t=0; t<1; t+=(0.001f)) {
linePoint = CalculatePointOfLine(t,pointA,pointB);
gridLocal[(int)linePoint.x, (int)linePoint.y] = Color.blue;
}
//then I paint the line between selected points
//I am using a Bresenham algorithm to calculate the cells
gridGeneratedPointsText = ""; //setting up string to be filled with grid positions
int sizeW = (int)((gridLocal.GetLength(0)/(columns)));
int sizeH = (int)((gridLocal.GetLength(1)/(lines)));
for (int i=1; i<= grid.thickness; i++) {
Vector2 tempThickA = new Vector2(pointA.x + (i*sizeW),pointA.y+(i*sizeH));
Vector2 tempThickB = new Vector2(pointB.x + (i*sizeW),pointB.y+(i*sizeH));
gridLocal = lineBresenham (tempThickA, tempThickB, gridLocal);
}
//sends information to renderer
gridRenderer.SetGridTexture(grid.gridArray);
}
private void DumpDebugHeightmap()
{
// Re-normalize the terrain
float minHeight = float.MaxValue;
float maxHeight = -float.MaxValue;
Color[,] heightmap = new Color[m_root.heightmapData.GetLength(0), m_root.heightmapData.GetLength(1)];
System.Array.Copy(m_root.heightmapData, heightmap, m_root.heightmapData.GetLength(0) * m_root.heightmapData.GetLength(1));
for (int x = 0; x < heightmap.GetLength(0); ++x)
{
for (int y = 0; y < heightmap.GetLength(1); ++y)
{
if (heightmap[x, y].r < minHeight)
{
minHeight = heightmap[x, y].r;
}
if (heightmap[x, y].r > maxHeight)
{
maxHeight = heightmap[x, y].r;
}
}
}
for (int x = 0; x < heightmap.GetLength(0); ++x)
{
for (int y = 0; y < heightmap.GetLength(1); ++y)
{
heightmap[x, y].r = (heightmap[x, y].r - minHeight) / (maxHeight - minHeight);
}
}
Color[] texFormatData = new Color[Resolution * Resolution];
for (int y = 0; y < Resolution; ++y)
{
for (int x = 0; x < Resolution; ++x)
{
texFormatData[y * Resolution + x] = heightmap[x, y];
texFormatData[y * Resolution + x].a = 1.0f;
}
}
Texture2D testTexture = new Texture2D(Resolution, Resolution);
testTexture.SetPixels(texFormatData);
System.IO.File.WriteAllBytes(@"D:\heightmap.png", testTexture.EncodeToPNG());
}
public static Texture2D DrawAsPointsToTexture(GraphicsDevice GD)
{
Color[,] Col2D = new Color[(int)GameValues.ScreenSize.X, (int)GameValues.ScreenSize.Y];
for (int x = 0; x < Col2D.GetLength(0); x++)
for (int y = 0; y < Col2D.GetLength(1); y++)
Col2D[x, y] = Color.Black;
List<Particle> P = GetAllParticles();
for (int i = 0; i < P.Count; i++)
{
if (P[i].Pos.X > 0 && P[i].Pos.X < GameValues.ScreenSize.X && P[i].Pos.Y > 0 && P[i].Pos.Y < GameValues.ScreenSize.Y)
Col2D[(int)P[i].Pos.X, (int)P[i].Pos.Y] = P[i].C;
}
Color[] Col1D = new Color[Col2D.GetLength(0) * Col2D.GetLength(1)];
for (int x = 0; x < Col2D.GetLength(0); x++)
for (int y = 0; y < Col2D.GetLength(1); y++)
Col1D[x * y] = Col2D[x, y];
Texture2D Output = new Texture2D(GD, Col2D.GetLength(0), Col2D.GetLength(1));
Output.SetData(Col1D);
return Output;
}
/// <summary>
/// Sets the grid texture.
/// </summary>
/// <returns><c>true</c>, if grid texture was set, <c>false</c> otherwise.</returns>
/// <param name="grid">X and Y array of colors</param>
public bool SetGridTexture(Color[,] grid)
{
//first we make simple tests, to make sure our caller gets the correct feedback from this method
if (grid == null) return false;
if (grid.GetLength(0) == 0) return false;
if (grid.GetLength(1) == 0) return false;
if (texture == null) return false;
//we have to make sure the grid is compatible with the texture.
//if they are not compatible, I can just create a new texture with matching sizes.
if ((grid.GetLength(0) != texture.width) || (grid.GetLength(1) != texture.height)) {
texture = new Texture2D(grid.GetLength(0),grid.GetLength(1));
Debug.Log("New texture generated'" + grid.GetLength(0) + "," + grid.GetLength(1));
//This is required, since a new instance of Texture2D has been created on it.
guiTexture.texture = texture;
}
for (int x = 0; x < texture.width; x++) {
for (int y = 0; y < texture.height; y++) {
texture.SetPixel(x, y, grid[x,y]);
}
}
//Screen.SetResolution(texture.width, texture.height, false);
texture.Apply ();
return true;
}
/// <summary>
/// Sets entire wall to a single color
/// </summary>
/// <param name="c"></param>
private void setWallSolidColor(Color c)
{
Color[,] grid = new Color[StripCount, LedsPerStrip];
for (int i = 0; i < grid.GetLength(0); i++)
{
for (int j = 0; j < grid.GetLength(1); j++)
{
grid[i, j] = c;
}
}
_ledWall.SetWall(grid);
//TODO: use "set entire wall" message instead of entire grid
//_ledWall.SetWall(c);
}
public override string ToString()
{
Color[,] colors = new Color[3, 3];
foreach (Color color in coordinates.Keys)
{
foreach (Coordinate coordinate in coordinates[color])
{
colors[coordinate.GetRow(), coordinate.GetColumn()] = GetColor(coordinate);
}
}
string result = "";
for (int i = 0; i < colors.Length; i++)
{
for (int j = 0; j < colors.GetLength(i); j++)
{
char color = '.';
if (colors[i, j] != null)
{
color = colors[i, j].ToString()[0];
}
result += color + " ";
}
result += " \n";
}
return(result);
}
public void CreateTexture(Game1 game)
{
Texture2D newTexture = new Texture2D(game.GraphicsDevice, spriteWidth, spriteHeight);
Color[] headPixels = new Color[headSource.Width * headSource.Height];
Color[] bodyPixels = new Color[bodySource.Width * bodySource.Height];
Color[] finalPixels = new Color[bodySource.Width * bodySource.Height];
head.GetData <Color>(0, headSource, headPixels, 0, headSource.Width * headSource.Height);
body.GetData <Color>(0, bodySource, bodyPixels, 0, bodySource.Width * bodySource.Height);
for (int i = 0; i < headPixels.GetLength(0); i++)
{
int j = i + (HeadYOffset() * spriteWidth) + HeadXOffset();
if (j >= 0 && j < finalPixels.GetLength(0) && j % spriteWidth >= i % spriteWidth)
{
finalPixels[j] = headPixels[i];
}
}
for (int i = 0; i < bodyPixels.GetLength(0); i++)
{
if (finalPixels[i].A == 0)
{
finalPixels[i] = bodyPixels[i];
}
}
newTexture.SetData <Color>(0, new Rectangle(0, 0, bodySource.Width, bodySource.Height), finalPixels, 0, bodySource.Width * bodySource.Height);
this.texture = newTexture;
}
public static string WhoIsWinner(List <string> piecesPositionList)
{
char[] letters = "ABCDEFG".ToCharArray();
Color[,] board = new Color[8, 7];
string result = string.Empty;
foreach (var str in piecesPositionList)
{
var split = str.Split("_");
int x = Array.IndexOf(letters, char.Parse(split[0]));
int y = 0;
for (int i = 0; i < board.GetLength(1); i++)
{
if (board[x, i] == Color.Null)
{
y = i;
break;
}
}
board[x, y] = (Color)Enum.Parse(typeof(Color), split[1], true);
result = CheckWin(board);
if (result != "Draw")
{
break;
}
}
return(result);
}
/// <summary>
/// Описание метода для проверки принадлежности изображения к маркеру
/// </summary>
protected virtual void CheckOnMark()
{
// Проверка на соответсвию маркеру
if (drawing.Format == "a3")
{
// Проверка на ориентацию страницы,
// Если вертикальная, то ее нужно повернуть
if (drawing.Orientation == OrientationType.Vertical)
{
bitmap.RotateFlip(RotateFlipType.Rotate90FlipNone);
}
// Проверка на центральную точну, если ее нет то это не маркер и далее код не делать
Marker marker = info.Markers.FirstOrDefault(m => m.Position == MarkerPosition.Center);
if (marker == null)
{
return;
}
Color[,] colors = new Color[10, 10];
int x = (int)Math.Floor(marker.X * bitmap.HorizontalResolution / inch) - (colors.GetLength(0) / 2);
int y = (int)Math.Floor(marker.Y * bitmap.VerticalResolution / inch) - (colors.GetLength(1) / 2);
for (int i = 0; i < colors.GetLength(0); i++)
{
for (int j = 0; j < colors.GetLength(1); j++)
{
colors[i, j] = bitmap.GetPixel(x + j, y + i);
}
}
int count = 0;
foreach (Color color in colors)
{
if (color.Name == "ff000000")
{
count++;
}
}
drawing.IsMarker = count > colors.Length * 0.8;
}
}
private void button1_Click(object sender, EventArgs e)
{
Color[,] color = processor.GetImageMatrix((Bitmap)processor.image);
Color[,] resize = new Color[color.GetLength(0) + 200, color.GetLength(1) + 200];
int x_ratio = resize.GetLength(0) / color.GetLength(0);
int y_ratio = resize.GetLength(1) / color.GetLength(1);
int px, py;
for (int i = 0, orx = 0; i < resize.GetLength(0) && orx < color.GetLength(0); i += x_ratio, orx++)
{
for (int j = 0, ory = 0; j < resize.GetLength(1) && ory < color.GetLength(1); j += y_ratio, ory++)
{
resize[i, j] = color[orx, ory];
}
}
drawMatrix(resize);
}
private void HandleKeyboardCustomEffect(byte[] message)
{
var keyboardEffect = new uint[6, 22];
MultiDemFromBytes(keyboardEffect, message);
var colors = new Color[6, 22];
for (var x = 0; x < colors.GetLength(0); x++)
{
for (var y = 0; y < colors.GetLength(1); y++)
{
colors[x, y] = ColorFromUint(keyboardEffect[x, y]);
}
}
OnKeyboardColorUpdate?.Invoke(colors);
CheckForChampionUpdate(colors);
}
private void UpdateTextureSize()
{
var currentTexture = (Color[, ])Stencil.Clone();
var newTexture = new Color[TextureWidth, TextureHeight];
for (int x = 0; x < TextureWidth; x++)
{
for (int y = 0; y < TextureHeight; y++)
{
newTexture[x, y] = Color.Transparent;
}
}
var largerX = currentTexture.GetLength(0) > newTexture.GetLength(0) ? currentTexture.GetLength(0) : newTexture.GetLength(0);
var largerY = currentTexture.GetLength(1) > newTexture.GetLength(1) ? currentTexture.GetLength(1) : newTexture.GetLength(1);
for (int i = 0; i < largerX; i++)
{
for (int j = 0; j < largerY; j++)
{
if (currentTexture.GetLength(0) <= i)
{
continue;
}
if (currentTexture.GetLength(1) <= j)
{
continue;
}
if (newTexture.GetLength(0) <= i)
{
continue;
}
if (newTexture.GetLength(1) <= j)
{
continue;
}
newTexture[i, j] = currentTexture[i, j];
}
}
Stencil = newTexture;
UpdateStencil();
}
public Color[] GenerateWalkableTexture()
{
Color[,] rawTexture = new Color[(_desiredScreenWidth / DrawScale), (_desiredScreenheight / DrawScale)];
for (int y = 0; y < _tilemap.Grid.GetLength(1); y++)
{
for (int x = 0; x < _tilemap.Grid.GetLength(0); x++)
{
Color drawColor;
if (_tilemap.Grid[x, y])
{
drawColor = Color.White * 0;
}
else
{
drawColor = Color.Lime * 0.5f;
}
for (int pixelX = 0; pixelX < 16; pixelX++)
{
for (int pixelY = 0; pixelY < 16; pixelY++)
{
rawTexture[(x * 16) + pixelX, (y * 16) + pixelY] = drawColor;
}
}
}
}
Color[] output = new Color[(_desiredScreenWidth / DrawScale) * (_desiredScreenheight / DrawScale)];
int i = 0;
for (int y = 0; y < rawTexture.GetLength(1); y++)
{
for (int x = 0; x < rawTexture.GetLength(0); x++)
{
output[i] = rawTexture[x, y];
i++;
}
}
return(output);
}
private Color[,] ShearX(Color[,] colors, float angle)
{
//return colors;
float alpha = -(float)Math.Tan(angle / 2f);
int yl = colors.GetLength(1);
int xd = (int)(((float)colors.GetLength(1) - 1f) * alpha);
int xl = Math.Abs(xd) + colors.GetLength(0);
Color[,] newColors = new Color[xl, yl];
for (int i = 0; i < newColors.GetLength(0); i++)
{
for (int j = 0; j < newColors.GetLength(1); j++)
{
newColors[i, j] = Color.Transparent;
}
}
for (int i = 0; i < colors.GetLength(0); i++)
{
for (int j = 0; j < colors.GetLength(1); j++)
{
if (colors[i, j] == Color.Transparent)
{
continue;
}
if (i != 0)
{
float f = frac(alpha * (float)j);
newColors[i + (int)(j * alpha), j] = Color.FromArgb(
(int)((1 - f) * colors[i, j].R + f * colors[i - 1, j].R),
(int)((1 - f) * colors[i, j].G + f * colors[i - 1, j].G),
(int)((1 - f) * colors[i, j].B + f * colors[i - 1, j].B)
);
}
else
{
newColors[i + (int)(j * alpha), j] = colors[i, j];
}
}
}
return(newColors);
}
public static Color[] ToColorsA(RayCastManager rtc, int bits)
{
int dgx = rtc.getSizeX();
int dgy = rtc.getSizeY();
int dgz = rtc.getSizeZ();
Color[,,] colors = new Color[dgx, (dgy / bits), dgz];
for (int gx = 0; gx < dgx; gx++)
{
for (int gy = 0; gy < dgy / bits; gy++)
{
for (int gz = 0; gz < dgz; gz++)
{
int iv = 0;
for (int n = 0; n < bits; n++)
{
iv |= rtc.testBlock(gx, gy * bits + n, gz, RayCastBlockType.Opacity) ? (1 << n) : 0;
}
float a = iv / (float)((1 << bits) - 1);
colors[gx, gy, gz] = new Color(0, 0, 0, a);
}
}
}
int sizeX = colors.GetLength(0);
int sizeY = colors.GetLength(1);
int sizeZ = colors.GetLength(2);
Color[] rlt = new Color[sizeX * sizeY * sizeZ];
for (int x = 0; x < sizeX; x++)
{
for (int y = 0; y < sizeY; y++)
{
for (int z = 0; z < sizeZ; z++)
{
rlt[z * sizeY * sizeX + y * sizeX + x] = colors[x, y, z];
}
}
}
return(rlt);
}
private Color[,] ShearY(Color[,] colors, float angle)
{
float beta = (float)Math.Sin(angle);
int xl = colors.GetLength(0);
int yd = Math.Abs((int)(((float)colors.GetLength(0) - 1f) * beta));
int yl = yd + colors.GetLength(1);
Color[,] newColors = new Color[xl, yl];
for (int i = 0; i < newColors.GetLength(0); i++)
{
for (int j = 0; j < newColors.GetLength(1); j++)
{
newColors[i, j] = Color.Transparent;
}
}
for (int i = 0; i < colors.GetLength(0); i++)
{
float f = Math.Abs(frac(beta * (float)i));
for (int j = 0; j < colors.GetLength(1); j++)
{
if (colors[i, j] == Color.Transparent)
{
continue;
}
if (j != 0)
{
newColors[i, j + (int)(i * beta) + yd] = Color.FromArgb(
(int)((1 - f) * colors[i, j].R + f * colors[i, j - 1].R),
(int)((1 - f) * colors[i, j].G + f * colors[i, j - 1].G),
(int)((1 - f) * colors[i, j].B + f * colors[i, j - 1].B)
);
}
else
{
newColors[i, j + (int)(i * beta) + yd] = colors[i, j];
}
}
}
return(newColors);
}
