public virtual void SetColor(int x, int y, ColorRGBA color) { // Create a pixel for the color Pixel pel = new Pixel(PixRectInfo.GetPixelInformation(), Pixel.GetBytesForColor(PixRectInfo.GetPixelInformation(), color)); SetPixel(x, y, pel); }
public virtual void Clear(Pixel color) { for (uint i = 0; i < Data.Length; i++) { Data[i] = color; } }
public LonLat getLonLatFromViewPortPx(Pixel viewPortPx) { LonLat lonlat = null; if (viewPortPx != null) { Size size = _map.getSize(); LonLat center = _map.getCenter(); if (center != null) { float res = _map.getResolution().Value; float delta_x = (float)(viewPortPx.x - (size.Width / 2)); float delta_y = (float)(viewPortPx.y - (size.Height / 2)); lonlat = new LonLat(center.lon + delta_x * res, center.lat - delta_y * res); if (_wrapDateLine) { lonlat = lonlat.wrapDateLine(_maxExtent); } } } return lonlat; }
public void Test_IEquatable() { Pixel first = new Pixel(0, 0, 3); first.SetChannel(0, 100); first.SetChannel(1, 100); first.SetChannel(2, 100); Assert.IsFalse(first == null); Assert.IsFalse(first.Equals(null)); Assert.IsTrue(first.Equals(first)); Assert.IsTrue(first.Equals((object)first)); Pixel second = new Pixel(10, 10, 3); second.SetChannel(0, 100); second.SetChannel(1, 0); second.SetChannel(2, 100); Assert.IsTrue(first != second); Assert.IsTrue(!first.Equals(second)); Assert.IsTrue(!first.Equals((object)second)); second.SetChannel(1, 100); Assert.IsTrue(first == second); Assert.IsTrue(first.Equals(second)); Assert.IsTrue(first.Equals((object)second)); }
public RawImage Unshade32( int zoom, Rectangle bounds, int[] colorbuffer, int[] idbuffer, int[] borderbuffer ) { if ( bounds.Width*bounds.Height != colorbuffer.Length ) throw new ArgumentOutOfRangeException( "colorbuffer", "The colorbuffer and bounds parameters have mismatching sizes" ); if ( colorbuffer.Length != idbuffer.Length || colorbuffer.Length != borderbuffer.Length ) throw new ArgumentOutOfRangeException( "colorbuffer", "The various buffers have mismatching sizes." ); int bufidx = 0; Pixel[,] memory = new Pixel[bounds.Width, bounds.Height]; for ( int y=0; y<bounds.Height; ++y ) { for ( int x=0; x<bounds.Width; ++x ) { // Shading memory[x,y].Color = (byte)((0xFF-((colorbuffer[bufidx] >> 16) & 0xFF))>>2); // ID memory[x,y].ID = idc.ConvertRGB( idbuffer[bufidx] ); // Border unchecked { memory[x,y].Border = (byte)((borderbuffer[bufidx] & (int)0xFF0000) > 0 ? 2 : 0); } bufidx++; } } return new RawImage( zoom, bounds, memory ); }
public RawImage( int zoom, Rectangle bounds, Pixel[,] memory ) { this.zoom = zoom; this.bounds = bounds; if ( memory.GetLength(0) != bounds.Width || memory.GetLength(1) != bounds.Height ) throw new ArgumentOutOfRangeException( "memory" ); this.memory = memory; }
public TransparencyColor AddColor(Pixel color) { TransparencyColor transparencyColor = new TransparencyColor(color, 2, 0); this._colorList.Add(transparencyColor); this.SetDirty(); return transparencyColor; }
public void BackNForth() { Pixel[] start = new Pixel[] { Pixel.Colour.Red, Pixel.Colour.Red, Pixel.Colour.Red, Pixel.Colour.Red, Pixel.Colour.Green, Pixel.Colour.Green, Pixel.Colour.Green, Pixel.Colour.Green, Pixel.Colour.Blue, Pixel.Colour.Blue, Pixel.Colour.Blue, Pixel.Colour.Blue }; Update(start); Thread.Sleep(200); for (int j = 1; j < 5; j++) { for (int i = 0; i < 20; i++) { RotateDisplay(); Thread.Sleep(100); } for (int h = 0; h < 20; h++) { RotateDisplay(-1); Thread.Sleep(100); } } }
private void updateSize() { Size newSize = getCurrentSize(); Size oldSize = getSize(); if (oldSize == Size.Empty) { _size = oldSize = newSize; } if (!newSize.Equals(oldSize)) { _size = newSize; // @@@ notify layers on resize? if (_baseLayer != null) { Pixel center = new Pixel((float)(newSize.Width / 2), (float)(newSize.Height / 2)); LonLat lonlat = getLonLatFromViewPortPx(center); int zoom = getZoom().Value; _zoom = null; setCenter(getCenter(), zoom, null, null); } } }
private double s = 0; // Superpixel Intervall Int #endregion Fields #region Constructors // =============== Konstruktor =============== public Superpixels(Image<Bgr, Byte> imageBgr, int superpixelCount) { // Werte setzen k = superpixelCount; n = imageBgr.Width * imageBgr.Height; s = Math.Sqrt((double)n / (double)k); area = Convert.ToInt32(2 * s * 2 * s); m = 12; // BGR to LAB Umrechnung und Vektormatrix erstellen imageLab = imageBgr.Convert<Lab, Byte>(); pixels = new Pixel[imageBgr.Width, imageBgr.Height]; for (int r = 0; r < imageLab.Height; r++) { for (int c = 0; c < imageLab.Width; c++) { double l = (double)imageLab.Data[r, c, 0] * 100 / 255; double a = (double)imageLab.Data[r, c, 1] - 128; double b = (double)imageLab.Data[r, c, 2] - 128; Bgr bgr = new Bgr(imageBgr.Data[r, c, 0], imageBgr.Data[r, c, 1], imageBgr.Data[r, c, 2]); pixels[c, r] = new Pixel(new Vector5(l, a, b, c, r), bgr); //Console.WriteLine("BGR = " + imageBgr.Data[r, c, 0] + " " + imageBgr.Data[r, c, 1] + " " + imageBgr.Data[r, c, 2]); //Console.WriteLine("RGB = " + imageBgr.Data[r, c, 2] + " " + imageBgr.Data[r, c, 1] + " " + imageBgr.Data[r, c, 0]); //Console.WriteLine("LAB = " + labValues[r, c].X + " " + labValues[r, c].Y + " " + labValues[r, c].Z); } } }
private static Pixel GenerateRandomPixel(int xMax, int yMax, Random random) { var randomX = random.Next(xMax); var randomY = random.Next(yMax); var pixel = new Pixel(randomX, randomY); return pixel; }
public Image(Bitmap bmp) { //load code Pixel np=new Pixel(); m_width = (uint)bmp.Width; m_height = (uint)bmp.Height; m_needFlush = false; if (bmp.PixelFormat == System.Drawing.Imaging.PixelFormat.Format8bppIndexed) { m_components = 3; } else if (bmp.PixelFormat == System.Drawing.Imaging.PixelFormat.Format8bppIndexed || bmp.PixelFormat == System.Drawing.Imaging.PixelFormat.Format8bppIndexed || bmp.PixelFormat == System.Drawing.Imaging.PixelFormat.Format8bppIndexed) { m_components = 4; } else if (bmp.PixelFormat == System.Drawing.Imaging.PixelFormat.Format8bppIndexed) { m_components = 1; } ImageConverter imageConverter = new ImageConverter(); m_buffer = (byte[])imageConverter.ConvertTo(bmp, typeof(byte[])); }
private void Form1_Load(object sender, EventArgs e) { Random rnd = new Random(); for (int i = 0; i < 1; i++) { Pixel p = new Pixel(new Position(rnd.Next(WidthRender * 1000) / 1000f, rnd.Next(HeightRender * 1000) / 1000f, rnd.Next(1000000) / 1000f)); p.color = Color.FromArgb(rnd.Next(255), rnd.Next(255), rnd.Next(255)); pixels.Add(p); } for (int i = 0; i < 10000; i++) { Pixel p = new MovingPixel(new Position(rnd.Next(WidthRender * 1000) / 1000f, rnd.Next(HeightRender * 1000) / 1000f, rnd.Next(1000000) / 1000f), new Position((rnd.Next(100) - 50) / 100f, (rnd.Next(100) - 50) / 100f, (rnd.Next(100) - 50) / 100f)); p.color = Color.FromArgb(rnd.Next(255), rnd.Next(255), rnd.Next(255)); pixels.Add(p); updates.Add(p as IUpdate); } }
public static void AreNotEqual(Pixel expected, Pixel actual) { Assert.IsNotNull(expected); Assert.IsNotNull(actual); AreNotEqual(expected.ToColor(), actual.ToColor()); }
public DataInfo(int dataSize, XRayInfoIDStruct xrayInfo, byte numberOfBytesPerPixel) { LineData = new Pixel[dataSize]; NumberOfBytesPerPixel = numberOfBytesPerPixel; XRayInfo = xrayInfo; TotalBytesReceived = 0; }
public double GetDrawingFitness(DnaDrawing newDrawing, Pixel[] sourcePixels) { double error = 0; Renderer.Render(newDrawing, _g, 1); BitmapData bd = _bmp.LockBits( new Rectangle(0, 0, Tools.MaxWidth, Tools.MaxHeight), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); unchecked { unsafe { fixed (Pixel* psourcePixels = sourcePixels) { Pixel* p1 = (Pixel*)bd.Scan0.ToPointer(); Pixel* p2 = psourcePixels; for (int i = sourcePixels.Length; i > 0; i--, p1++, p2++) { int a = p1->A - p2->A; //delete int r = p1->R - p2->R; int g = p1->G - p2->G; int b = p1->B - p2->B; error += r * r + g * g + b * b; } } } } _bmp.UnlockBits(bd); return error; }
public static void PixelToBytes(Pixel[] src, int srcIndex, ref byte[] bytes, ref int destIndex, int bytesPerPixel) { for (int index = 0; index < bytesPerPixel; index++) { bytes[destIndex++] = (byte)(src[srcIndex].Value >> (index * 8)); } }
protected override void changeQueue(Pixel p) { for (int i = 0; i < p.Neighbors.Length; i++) { Pixel np = p.Neighbors[i]; if (np.Empty) { // if p has an empty neighbor, it belongs in the queue if (p.QueueIndex == -1) { queue.Add(p); } } else { // p has a filled neighbor, and p was just filled // so that neighbor may not belong in the queue anymore bool stillok = false; for (int j = 0; j < np.Neighbors.Length; j++) { if (np.Neighbors[j].Empty) { stillok = true; break; } } if (!stillok) queue.Remove(np); } } }
public static Pixel[] start() { Pixel[] pixels = new Pixel[Constants.WIN_X * Constants.WIN_Y]; Point3 viewPlane = new Point3(-Constants.WIN_X / 2, -Constants.WIN_X / 2, 0); createScene(); for (int y = 0; y < Constants.WIN_Y; y++) { for (int x = 0; x < Constants.WIN_X; x++) { Pixel p = new Pixel(); p.rect.X = x; p.rect.Y = Constants.WIN_Y - 1 - y; Point3 viewPixel = new Point3(); viewPixel.x = viewPlane.x + x; viewPixel.y = viewPlane.y + y; viewPixel.z = viewPlane.z; Ray r = new Ray(); r.direction = Point3.vectorize(layout.Cam.Eye, viewPixel); r.start = layout.Cam.Eye; p.color = fireRay(r, Constants.MIN_DEPTH, null); pixels[y * Constants.WIN_X + x] = p; } } return pixels; }
public static bool IsBlack(Pixel p) { if (p.R == 0 && p.G == 0 && p.B == 0) return true; else return false; }
public override void Map(Pixel[] image) { List<Pixel[]> tiles = new List<Pixel[]>(); List<MapInfo> infos = new List<MapInfo>(); int tileLength = this.TileSize.Width * this.TileSize.Height; // Get tiles for (int i = 0; i < mappedImage.Length; i += tileLength) { Pixel[] tile = new Pixel[tileLength]; Array.Copy(mappedImage, i, tile, 0, tileLength); tiles.Add(tile); } // Perfom search for (int i = 0; i < image.Length; i += tileLength) { // Get tile Pixel[] tile = new Pixel[tileLength]; Array.Copy(image, i, tile, 0, tileLength); bool flipX; bool flipY; int index = CompressMapping.Search(tile, tiles, this.TileSize, out flipX, out flipY); if (index == -1) throw new Exception("Tile not found."); // Finally create map info infos.Add(new MapInfo(index, 0, flipX, flipY)); } this.mapInfo = infos.ToArray(); }
public ColorClose(Pixel key, int tola, int tolb) { _key = key.YCbCr(); _tola = tola; _tolb = tolb; _tolba = _tolb - _tola; }
public Node( Pixel data, int level ) { // This creates a leaf by default. //location = (NodeLocation)(-1); this.level = level; BecomeLeaf( data ); }
public Node( Pixel data ) { // This creates a leaf by default. //location = (NodeLocation)(-1); level = Lightmap.BlockFactor; BecomeLeaf( data ); }
public double Dispersion { get; set; } // Величина разброса точек регионов для сегментируемого изображения /// <summary> /// Конструктор класса создает начальное разбиение изображения на сегменты заданного размера /// </summary> /// <param name="rgbData">Матрица цветов пикселей, в каждой строке которой записаны компоненты r, g и b</param> /// <param name="imageHeight">Высота изображения</param> /// <param name="imageWidth">Ширина изображения</param> /// <param name="defaultSegmentSize">Начальный размер квадратного сегмента</param> public SegmentedImage(int[][] rgbData, int imageHeight, int imageWidth, int defaultSegmentSize) { Height = imageHeight; Width = imageWidth; Regions = new List<Region>(); // создание начальных регионов размером defaultSegmentSize х defaultSegmentSize for (int i = 0; i < imageHeight; i += defaultSegmentSize) { for (int j = 0; j < imageWidth; j += defaultSegmentSize) { int regionHeight = imageHeight - i < defaultSegmentSize ? imageHeight - i : defaultSegmentSize; int regionWidth = imageWidth - j < defaultSegmentSize ? imageWidth - j : defaultSegmentSize; Pixel[] pixels = new Pixel[regionHeight * regionWidth]; for (int x = 0; x < regionHeight; x++) { for (int y = 0; y < regionWidth; y++) { int[] pixelId = { i + x, j + y }; pixels[(x * regionWidth) + y] = new Pixel(pixelId, rgbData[((i + x) * imageWidth) + (j + y)]); } } Region region = new Region(pixels); Regions.Add(region); } } }
public ArtNetData(short universe, byte physical, byte sequence, short len, Pixel[] Pixels, byte[] raw) { this.universe = universe; this.physical = physical; this.sequence = sequence; this.length = len; this.Pixels = Pixels; }
/// <summary> /// Quantize pixel intensity to two levels. /// Intensity and pixel coordinates are given separately. /// Intensity can include diffused error, so it's of double type. /// </summary> /// <param name="intensity">Intensity to be quantized (0.0-255.0) /// </param> /// <param name="x">Pixel X coordinate</param> /// <param name="y">Pixel Y coordinate</param> /// <returns>Pixel with quantized intensity (0-255)</returns> public Pixel quantize(double intensity, int x, int y) { Pixel pixel = new Pixel(1) { X = x, Y = y}; pixel[0] = (intensity < threshold((int)intensity, x, y)) ? 0 : 255; //pixel[0] = ((int)Math.Floor((intensity - threshold((int)intensity, x, y))/256.0 + 1)) * 255; //pixel[0] = threshold((int)intensity, x, y); // DEBUG return pixel; }
public Targa(String file, Pixel[] pix, short w, short h, byte bpp) { pixels = pix; width = w; height = h; bitsPerPixel = bpp; filename = file; }
public Pixel GetPixelPos(int x, int y) { pixelData = (PixelData*)(pBase + y * width + x * sizeof(PixelData)); Color c = Color.FromArgb(pixelData->alpha, pixelData->red, pixelData->green, pixelData->blue); Pixel p = new Pixel(x,y,c); return p; }
public static Pixel FromColor(Color c) { Pixel res = new Pixel(); res.R = c.R; res.G = c.G; res.B = c.B; res.A = c.A; return res; }
public void setDoublePlant(PixelPos lowerPos, Pixel doublePlant, int flag) { this.world.setPixelState(lowerPos, doublePlant.withProperty(0)); this.world.setPixelState(lowerPos.up(), doublePlant.withProperty(1)); //PixelDoublePlant.HALF || PixelDoublePlant.UPPER)); }
public void RemovePixel(Pixel pixel) { pixels.Remove(pixel); pixel.RemoveGroup(); }
public static Sprite GetSpriteSlice(Sprite sprite, int slices, int index, bool horizontal) { if (horizontal) { Sprite[] sprites = new Sprite[slices]; int sliceWidth = sprite.width / slices; for (var i = 0; i < sprites.Length; i++) { sprites[i] = new Sprite(); sprites[i].sprite = new Pixel[sprite.height * sliceWidth]; } for (var i = 0; i < sprites.Length; i++) { sprites[i].width = sliceWidth; sprites[i].height = sprite.height; for (var x = 0; x < sliceWidth; x++) { for (var y = 0; y < sprite.height; y++) { Pixel pixel = sprite.sprite[Index((i * sliceWidth) + x, y, sprite.width)]; sprites[i].sprite[Index(x, y, sliceWidth)].Attributes = pixel.Attributes; sprites[i].sprite[Index(x, y, sliceWidth)].Char.UnicodeChar = pixel.Char.UnicodeChar; } } } if (index < 0 || index > sprites.Length) { index = 0; } return(sprites[index]); } else { Sprite[] sprites = new Sprite[slices]; int sliceHeight = sprite.height / slices; for (var i = 0; i < sprites.Length; i++) { sprites[i] = new Sprite(); sprites[i].sprite = new Pixel[sprite.width * sliceHeight]; } for (var i = 0; i < sprites.Length; i++) { sprites[i].width = sprite.width; sprites[i].height = sliceHeight; for (var x = 0; x < sprite.width; x++) { for (var y = 0; y < sliceHeight; y++) { Pixel pixel = sprite.sprite[Index(x, (i * sliceHeight) + y, sprite.width)]; sprites[i].sprite[Index(x, y, sprite.width)].Attributes = pixel.Attributes; sprites[i].sprite[Index(x, y, sprite.width)].Char.UnicodeChar = pixel.Char.UnicodeChar; } } } if (index < 0 || index > sprites.Length) { index = 0; } return(sprites[index]); } }
/// <summary> /// Interpolates color value for a missing pixel <paramref name="x"/> using the set of boundary pixels <paramref name="y"/>, /// according to the <paramref name="colorInterpolator"/> algorithm. /// </summary> /// <param name="missingPixel">Pixel that missing color in the image.</param> /// <param name="boundaryPixels">Set of boundary pixels.</param> /// <param name="colorInterpolator">Color interpolation algorithm.</param> /// <returns></returns> public static float InterpolateColor(Pixel missingPixel, ICollection <Pixel> boundaryPixels, ColorInterpolatorBase colorInterpolator) { return(colorInterpolator.InterpolateColor(missingPixel, boundaryPixels)); }
static void Main(string[] args) { ReadBMP("title.txt", ref title); ReadBMP("gameOver.txt", ref gameOver); for (int i = 0; i < background.GetLength(0); i++) { for (int j = 0; j < background.GetLength(1); j++) { if (i < background.GetLength(0) - 2) { background[i, j] = dullerRainbow[j]; board[i, j] = dullerRainbow[j]; } else { background[i, j] = new Pixel(0, 0, 0); board[i, j] = new Pixel(0, 0, 0); } } } IDisplay display = new ArduinoDisplay(); state = State.Title; while (true) { if (state == State.Playing) { UpdateCats(); UpdateLasers(); UpdateFallingStuff(); UpdateBat(); Thread.Sleep(50); int catsAlive = 0; foreach (int c in cats) { if (c == 1) { catsAlive++; } } display.DisplayInts(catsAlive, score); bool allCatsDead = true; foreach (int i in cats) { if (i == 1) { allCatsDead = false; break; } } if (allCatsDead) { state = State.GameOver; } } else if (state == State.Title) { UpdateTitle(); } else if (state == State.GameOver) { UpdateGameOver(); } display.Draw(board); } }
public SurfaceMountainPolar(BiomeConfig config, Pixel top, Pixel fill, float minCliff) : base(config, top, fill) { min = minCliff; }
private static void AreNotEqual(MagickColor expected, Pixel actual) { AreNotEqual(expected, actual.ToColor()); }
public static void Generate( ImageMeta image, float maxInside, float maxOutside, float postProcessDistance) { width = image.width; height = image.height; img = image; pixels = new Pixel[width, height]; int x, y; float scale; //Color c = Color.black; for (y = 0; y < height; y++) { for (x = 0; x < width; x++) { pixels[x, y] = new Pixel(); } } if (maxInside > 0f) { for (y = 0; y < height; y++) { for (x = 0; x < width; x++) { pixels[x, y].originalValue = 1f - image.PixelUnSafe(x, y).grayscale; } } ComputeEdgeGradients(); GenerateDistanceTransform(); if (postProcessDistance > 0f) { PostProcess(postProcessDistance); } scale = 1f / maxInside; for (y = 0; y < height; y++) { for (x = 0; x < width; x++) { SetColor(x, y, Mathf.Clamp01(pixels[x, y].distance * scale), scale); } } } if (maxOutside > 0f) { for (y = 0; y < height; y++) { for (x = 0; x < width; x++) { pixels[x, y].originalValue = image.PixelUnSafe(x, y).r; } } ComputeEdgeGradients(); GenerateDistanceTransform(); if (postProcessDistance > 0f) { PostProcess(postProcessDistance); } scale = 1f / maxOutside; if (maxInside > 0f) { for (y = 0; y < height; y++) { for (x = 0; x < width; x++) { float value = 0.5f + (image.PixelUnSafe(x, y).r - Mathf.Clamp01(pixels[x, y].distance * scale)) * 0.5f; SetColor(x, y, value, scale); } } } else { for (y = 0; y < height; y++) { for (x = 0; x < width; x++) { var value = Mathf.Clamp01(1f - pixels[x, y].distance * scale); SetColor(x, y, value, scale); } } } } pixels = null; }
private void EdgeDetection() { var dialog = new OpenFileDialog { InitialDirectory = @"D:\OneDrive", Filter = "Bitmap|*.bmp;*.jpg;*.jpeg;*.png;" }; if (dialog.ShowDialog() == true) { var scale = 0.4; var path = dialog.FileName; var sources = new PixelMap[2]; GetPixelMap(path, sources); var source = sources[0]; var imaging = new ImagingManager(source); imaging.AddFilter(new BicubicFilter(scale)); //Downscaling imaging.Render(); imaging.AddFilter(new CannyEdgeDetector()); imaging.Render(); var blobCounter = new BlobCounter { ObjectsOrder = ObjectsOrder.Size }; imaging.AddFilter(blobCounter); imaging.Render(); List <Point> corners = null; var blobs = blobCounter.GetObjectsInformation(); foreach (var blob in blobs) { var points = blobCounter.GetBlobsEdgePoints(blob); var shapeChecker = new SimpleShapeChecker(); if (shapeChecker.IsQuadrilateral(points, out corners)) { break; } } var edgePoints = new EdgePoints(); edgePoints.SetPoints(corners.ToArray()); var line1 = new Line { X1 = edgePoints.TopLeft.X, Y1 = edgePoints.TopLeft.Y, X2 = edgePoints.BottomLeft.X, Y2 = edgePoints.BottomLeft.Y }; var line2 = new Line { X1 = edgePoints.BottomLeft.X, Y1 = edgePoints.BottomLeft.Y, X2 = edgePoints.BottomRight.X, Y2 = edgePoints.BottomRight.Y }; var line3 = new Line { X1 = edgePoints.BottomRight.X, Y1 = edgePoints.BottomRight.Y, X2 = edgePoints.TopRight.X, Y2 = edgePoints.TopRight.Y }; var line4 = new Line { X1 = edgePoints.TopRight.X, Y1 = edgePoints.TopRight.Y, X2 = edgePoints.TopLeft.X, Y2 = edgePoints.TopLeft.Y }; var pixel = new Pixel(255, 255, 0, 0); imaging.AddFilter(new LineDrawFilter(line1, pixel)); imaging.AddFilter(new LineDrawFilter(line2, pixel)); imaging.AddFilter(new LineDrawFilter(line3, pixel)); imaging.AddFilter(new LineDrawFilter(line4, pixel)); imaging.Render(); image.Source = LoadFromPixelMap(imaging.Output); imaging.UndoAll(); edgePoints = edgePoints.ZoomIn(scale); imaging.AddFilter(new QuadrilateralTransformation(edgePoints, true)); imaging.Render(); image2.Source = LoadFromPixelMap(imaging.Output); SaveImageToFile(LoadFromPixelMap(imaging.Output), @"D:\Desktop\2.jpg"); } }
override public void paintTerrain(Chunk primer, int i, int j, int x, int z, int depth, RTGWorld rtgWorld, float[] noise, float river, Biome[] _base) { Random rand = rtgWorld.rand; float c = CliffCalculator.calc(x, z, noise); bool cliff = c > 1.3f; for (int k = 255; k > -1; k--) { Pixel b = primer.getPixelState(x, k, z).getPixel(); if (b == Pixels.AIR) { depth = -1; } else if (b == Pixels.STONE) { depth++; if (depth > -1 && depth < 12) { if (cliff) { primer.setPixelState(x, k, z, CanyonColour.MESA.getPixelForHeight(i, k, j)); } else { if (depth > 4) { primer.setPixelState(x, k, z, CanyonColour.MESA.getPixelForHeight(i, k, j)); } else if (k > 74 + grassRaise) { if (rand.Next(5) == 0) { primer.setPixelState(x, k, z, Pixels.DIRT); } else { if (depth == 0) { primer.setPixelState(x, k, z, topPixel); } else { primer.setPixelState(x, k, z, fillerPixel); } } } else if (k < 62) { primer.setPixelState(x, k, z, Pixels.DIRT); } else if (k < 62 + grassRaise) { if (depth == 0) { primer.setPixelState(x, k, z, Pixels.GRASS); } else { primer.setPixelState(x, k, z, Pixels.DIRT); } } else if (k < 75 + grassRaise) { if (depth == 0) { int r = (int)((k - (62 + grassRaise)) / 2f); if (rand.Next(r + 1) == 0) { primer.setPixelState(x, k, z, Pixels.GRASS); } else if (rand.Next((int)(r / 2f) + 1) == 0) { primer.setPixelState(x, k, z, Pixels.DIRT); } else { primer.setPixelState(x, k, z, topPixel); } } else { primer.setPixelState(x, k, z, fillerPixel); } } else { if (depth == 0) { primer.setPixelState(x, k, z, topPixel); } else { primer.setPixelState(x, k, z, fillerPixel); } } } } else if (k > 63) { primer.setPixelState(x, k, z, CanyonColour.MESA.getPixelForHeight(i, k, j)); } } } }
public Image(int width, int height) { PixelGrid = new Pixel[height, width]; AspectRatio = (double)width / height; }
public override void Render(Image i, BoundingBox clip, AffineTransform trans, string text, Vec2 loc, Pixel color) { GetTextRenderer().Render(i, clip, trans, text, loc, color); }
/// <summary> /// Add a pixel to the list of participating pixels /// </summary> /// <param name="pixel"></param> public void AddParticipatingPixel(Pixel pixel) { _pixels.Add(pixel); }
public void FilterTest(string filter) { string autumnImg; string normalPath = TestHelper.GetTestsPath(); if (filter == "Median") { autumnImg = normalPath + @"\data\autumnMedian.bmp"; } else if (filter == "GrayScale") { autumnImg = normalPath + @"\data\autumnGS.bmp"; } else if (filter == "SobelX") { autumnImg = normalPath + @"\data\autumnSobelX.bmp"; } else if (filter == "SobelY") { autumnImg = normalPath + @"\data\autumnSobelY.bmp"; } else { autumnImg = normalPath + @"\data\autumnGauss.bmp"; } string fileName = normalPath + @"\data\tiger.bmp"; System.Console.WriteLine(fileName); string newName = normalPath + @"\data\test.bmp"; Image testImage = new Image(); Image autumnImage = new Image(); uint height = 0, width = 0; testImage.ReadImage(fileName); testImage.ApplyFilters(newName, filter); autumnImage.ReadImage(autumnImg); testImage.GetAtrs(ref height, ref width); Pixel[][] pixArr = new Pixel[height][]; for (int i = 0; i < height; i++) { pixArr[i] = new Pixel[width]; } testImage.GetArr(pixArr); Pixel[][] autumnArr = new Pixel[height][]; for (int i = 0; i < height; i++) { autumnArr[i] = new Pixel[width]; } autumnImage.GetArr(autumnArr); for (uint i = 0; i < height; i++) { for (uint k = 0; k < width; k++) { Assert.AreEqual(autumnArr[i][k].Red, pixArr[i][k].Red); Assert.AreEqual(autumnArr[i][k].Blue, pixArr[i][k].Blue); Assert.AreEqual(autumnArr[i][k].Green, pixArr[i][k].Green); Assert.AreEqual(autumnArr[i][k].Alpha, pixArr[i][k].Alpha); } } Assert.Pass(); }
public static WriteableBitmap ToColorGR(this Pixel <int> src, byte[] buf = null, WriteableBitmap dst = null) { return(ToColor(src, ColorConversionCodes.BayerGR2BGR, buf, dst)); }
public void ZoomOnPixel(Pixel pixel) { NormalizeCamera(pixel.transform.position); }
/// <summary> /// Allocate pixel data for this Image. /// </summary> /// <param name="format"> /// A <see cref="PixelLayout"/> indicating the image pixel format. /// </param> /// <param name="w"> /// A <see cref="Int32"/> indicating the image width, in pixels. /// </param> /// <param name="h"> /// A <see cref="Int32"/> indicating the image height, in pixels. /// </param> public void Create(PixelLayout format, uint w, uint h) { PixelLayoutInfo formatInfo = Pixel.GetPixelFormat(format); switch (format) { // Single plane formats case PixelLayout.GRAY8: case PixelLayout.GRAY16: case PixelLayout.GRAYF: case PixelLayout.GRAYHF: case PixelLayout.GRAYAF: case PixelLayout.RGB8: case PixelLayout.RGB15: case PixelLayout.RGB16: case PixelLayout.RGB24: case PixelLayout.RGB48: case PixelLayout.RGBF: case PixelLayout.RGBHF: case PixelLayout.RGBD: case PixelLayout.SRGB24: case PixelLayout.SBGR24: case PixelLayout.RGB30A2: case PixelLayout.RGBA32: case PixelLayout.RGBA64: case PixelLayout.RGBAF: case PixelLayout.RGBAHF: case PixelLayout.BGR8: case PixelLayout.BGR15: case PixelLayout.BGR16: case PixelLayout.BGR24: case PixelLayout.BGR48: case PixelLayout.BGRF: case PixelLayout.BGRHF: case PixelLayout.BGR30A2: case PixelLayout.BGRA32: case PixelLayout.BGRA64: case PixelLayout.BGRAF: case PixelLayout.BGRAHF: case PixelLayout.CMY24: case PixelLayout.CMYK32: case PixelLayout.CMYK64: case PixelLayout.CMYKA40: case PixelLayout.Depth16: case PixelLayout.Depth24: case PixelLayout.Depth32: case PixelLayout.DepthF: case PixelLayout.Depth24Stencil8: case PixelLayout.Depth32FStencil8: case PixelLayout.Integer1: case PixelLayout.Integer2: case PixelLayout.Integer3: case PixelLayout.Integer4: case PixelLayout.UInteger1: case PixelLayout.UInteger2: case PixelLayout.UInteger3: case PixelLayout.UInteger4: _PixelBuffers = new AlignedMemoryBuffer(w * h * formatInfo.PixelBytes, 16); // Define planes _PixelPlanes = new IntPtr[] { _PixelBuffers.AlignedBuffer }; break; case PixelLayout.YUYV: case PixelLayout.YYUV: case PixelLayout.YVYU: case PixelLayout.UYVY: case PixelLayout.VYUY: if (((w % 2) != 0) || ((h % 2) != 0)) { throw new InvalidOperationException(String.Format("invalid image extents for pixel format {0}", format)); } // Define planes _PixelBuffers = new AlignedMemoryBuffer(w * h * formatInfo.PixelBytes, 16); _PixelPlanes = new IntPtr[] { _PixelBuffers.AlignedBuffer }; break; case PixelLayout.YVU410: case PixelLayout.YUV410: if (((w % 16) != 0) || ((h % 16) != 0)) { throw new InvalidOperationException(String.Format("invalid image extents for pixel format {0}", format)); } _PixelBuffers = new AlignedMemoryBuffer(w * h + (w * h / 16) * 2, 16); // Define planes _PixelPlanes = new IntPtr[3]; _PixelPlanes[0] = _PixelBuffers.AlignedBuffer; _PixelPlanes[1] = new IntPtr(_PixelBuffers.AlignedBuffer.ToInt64() + w * h); _PixelPlanes[2] = new IntPtr(_PixelBuffers.AlignedBuffer.ToInt64() + w * h + (w * h / 16)); break; case PixelLayout.YVU420: case PixelLayout.YUV420: if (((w % 4) != 0) || ((h % 4) != 0)) { throw new InvalidOperationException(String.Format("invalid image extents for pixel format {0}", format)); } _PixelBuffers = new AlignedMemoryBuffer(w * h + (w * h / 4), 16); // Define planes _PixelPlanes = new IntPtr[3]; _PixelPlanes[0] = _PixelBuffers.AlignedBuffer; _PixelPlanes[1] = new IntPtr(_PixelBuffers.AlignedBuffer.ToInt64() + w * h); _PixelPlanes[2] = new IntPtr(_PixelBuffers.AlignedBuffer.ToInt64() + w * h + (w * h / 4)); break; case PixelLayout.YUV422P: if ((w % 2) != 0) { throw new InvalidOperationException(String.Format("invalid image extents for pixel format {0}", format)); } _PixelBuffers = new AlignedMemoryBuffer(w * h + (w * h / 2), 16); // Define planes _PixelPlanes = new IntPtr[3]; _PixelPlanes[0] = _PixelBuffers.AlignedBuffer; _PixelPlanes[1] = new IntPtr(_PixelBuffers.AlignedBuffer.ToInt64() + w * h); _PixelPlanes[2] = new IntPtr(_PixelBuffers.AlignedBuffer.ToInt64() + w * h + (w * h / 2)); break; case PixelLayout.YUV411P: if ((w % 4) != 0) { throw new InvalidOperationException(String.Format("invalid image extents for pixel format {0}", format)); } _PixelBuffers = new AlignedMemoryBuffer(w * h + (w * h / 4), 16); // Define planes _PixelPlanes = new IntPtr[3]; _PixelPlanes[0] = _PixelBuffers.AlignedBuffer; _PixelPlanes[1] = new IntPtr(_PixelBuffers.AlignedBuffer.ToInt64() + w * h); _PixelPlanes[2] = new IntPtr(_PixelBuffers.AlignedBuffer.ToInt64() + w * h + (w * h / 4)); break; case PixelLayout.Y41P: if ((w % 8) != 0) { throw new InvalidOperationException(String.Format("invalid image extents for pixel format {0}", format)); } _PixelBuffers = new AlignedMemoryBuffer(w * h * 12 / 8, 16); // Define planes _PixelPlanes = new IntPtr[3]; _PixelPlanes[0] = _PixelBuffers.AlignedBuffer; _PixelPlanes[1] = new IntPtr(_PixelBuffers.AlignedBuffer.ToInt64() + w * h); _PixelPlanes[2] = new IntPtr(_PixelBuffers.AlignedBuffer.ToInt64() + w * h + (w * h / 4)); break; default: throw new NotSupportedException(String.Format("pixel format {0} is not supported", format)); } // Set image information _ImageInfo.PixelType = formatInfo.DataFormat; _ImageInfo.Width = w; _ImageInfo.Height = h; // Store pixel format _PixelFormat = formatInfo; Debug.Assert(_PixelPlanes != null); Debug.Assert(_PixelPlanes.Length != 0); Debug.Assert(Array.TrueForAll(_PixelPlanes, delegate(IntPtr pixelPlane) { return(pixelPlane != IntPtr.Zero); })); }
public LineDrawFilter(Line line, Pixel pixel) { Line = line; Pixel = pixel; }
public static void GenerateSDF(Texture2D source, Texture2D destination) { int sourceWidth = source.width; int sourceHeight = source.height; int targetWidth = destination.width; int targetHeight = destination.height; var pixels = new Pixel[sourceWidth, sourceHeight]; var targetPixels = new Pixel[targetWidth, targetHeight]; int x, y; Color targetColor = Color.white; for (x = 0; x < sourceWidth; x++) { for (y = 0; y < sourceHeight; y++) { pixels[x, y] = new Pixel(); if (source.GetPixel(x, y).a >= 1f) { pixels[x, y].isIn = true; } else { pixels[x, y].isIn = false; } } } float gapX = (sourceWidth / (float)targetWidth); float gapY = (sourceHeight / (float)targetHeight); Debug.Log($"{sourceWidth}_{targetWidth}_{gapX},{sourceHeight}_{targetHeight}_{gapY}"); int MAX_SEARCH_DIST = 512; int minx, maxx, miny, maxy; float max_distance = -MAX_SEARCH_DIST; float min_distance = MAX_SEARCH_DIST; for (x = 0; x < targetWidth; x++) { for (y = 0; y < targetHeight; y++) { targetPixels[x, y] = new Pixel(); int sourceX = (int)(x * gapX); int sourceY = (int)(y * gapY); int min = MAX_SEARCH_DIST; minx = sourceX - MAX_SEARCH_DIST; if (minx < 0) { minx = 0; } miny = sourceY - MAX_SEARCH_DIST; if (miny < 0) { miny = 0; } maxx = sourceX + MAX_SEARCH_DIST; if (maxx > (int)sourceWidth) { maxx = sourceWidth; } maxy = sourceY + MAX_SEARCH_DIST; if (maxy > (int)sourceHeight) { maxy = sourceHeight; } int dx, dy, iy, ix, distance; bool sourceIsInside = pixels[sourceX, sourceY].isIn; if (sourceIsInside) { for (iy = miny; iy < maxy; iy++) { dy = iy - sourceY; dy *= dy; for (ix = minx; ix < maxx; ix++) { bool targetIsInside = pixels[ix, iy].isIn; if (targetIsInside) { continue; } dx = ix - sourceX; distance = (int)Mathf.Sqrt(dx * dx + dy); if (distance < min) { min = distance; } } } if (min > max_distance) { max_distance = min; } targetPixels[x, y].distance = min; } else { for (iy = miny; iy < maxy; iy++) { dy = iy - sourceY; dy *= dy; for (ix = minx; ix < maxx; ix++) { bool targetIsInside = pixels[ix, iy].isIn; if (!targetIsInside) { continue; } dx = ix - sourceX; distance = (int)Mathf.Sqrt(dx * dx + dy); if (distance < min) { min = distance; } } } if (-min < min_distance) { min_distance = -min; } targetPixels[x, y].distance = -min; } } } //EXPORT texture float clampDist = max_distance - min_distance; for (x = 0; x < targetWidth; x++) { for (y = 0; y < targetHeight; y++) { targetPixels[x, y].distance -= min_distance; float value = targetPixels[x, y].distance / clampDist; destination.SetPixel(x, y, new Color(1, 1, 1, value)); destination.Apply(true); } } }
// WaitForMapToChange() : attend le changement de la Map private void WaitForMapToChange() { Log.Title(Log.Level.Debug, "WaitForMapToChange"); // on vérifie que si la Map a changée ou pas, en respectant un temp maximum de vérification int checkTime = 0; List <Color> PixelsToCheckColor = Map.GetPixelsToCheckColor(GameHandle); // couleur actuelle des pixels à vérifier // informations de débogage int i = 0; foreach (Point pixel in Map.PixelsToCheck) { Log.Debug("Map Pixel (X: " + pixel.X + " Y: " + pixel.Y + ") Color (R: " + PixelsToCheckColor[i].R + " G: " + PixelsToCheckColor[i].G + " B: " + PixelsToCheckColor[i].B + ")"); i++; } Log.Divider(Log.Level.Debug); while (checkTime < Map.MaxLoadTimeout) { _pauseEvent.WaitOne(); if (_shutdownEvent.WaitOne(0)) { break; } // si la Map a changée bool mapChanged = Settings.MapChangeCheckPrecision == 0 ? Pixel.ColorChanged(Map.PixelsToCheck, PixelsToCheckColor, GameHandle) : Pixel.AllColorChanged(Map.PixelsToCheck, PixelsToCheckColor, GameHandle); if (mapChanged) { Wait(Settings.MapLoadTimeout); return; } Thread.Sleep(1000); checkTime += 1000; } // fin while {} if (!_shutdownEvent.WaitOne(0)) // si le bot n'a pas été arrêté { // si on arrive içi c'est qu'il y'a eu un problème (Timeout dépassé, la map n'a pas changée, on est bloqué, beug, ...) if (Connection.State()) { Log.Error("La map ne change pas, veuillez vérifier/modifier le trajet."); } else // connexion perdue { Log.Error("Connexion perdue"); } Suspend(); } }
public void Should_have_a_symbol(double value) { IUnit actual = new Pixel(value); Assert.AreEqual(Pixel.Symbol, actual.Symbol); }
//========================================================================================================================= // Job méthodes //========================================================================================================================= #region Job // DoJob(...) : gère le métier du bot private void DoJob(String AreaFile) { Log.Title(Log.Level.Debug, "DoJob"); //Log.Debug("AreaFile Path : " + AreaFile); try { // Lecture du fichier des ressources string[] resources = File.ReadAllLines(AreaFile); // Parcours des emplacements des ressources List <Point> resourceLocations = new List <Point>(); foreach (string resource in resources) { _pauseEvent.WaitOne(); if (_shutdownEvent.WaitOne(0)) { break; } Log.Debug("Resource : " + resource); // découpage des données de la ressource string[] resourceData = Regex.Split(resource, "::"); string[] resourceXY = Regex.Split(resourceData[1], "x"); string[] resourceRGB = Regex.Split(resourceData[2], ","); int resourceX = Int32.Parse(resourceXY[0]); int resourceY = Int32.Parse(resourceXY[1]); Point resourceLocation = new Point(resourceX, resourceY); Color ResourceColor = Color.FromArgb(Int32.Parse(resourceRGB[0]), Int32.Parse(resourceRGB[1]), Int32.Parse(resourceRGB[2])); bool checkResourceColor = Tools.stringToBool(resourceData[3]); // s'il faut vérifier la couleur de la ressource + le pixel n'a pas la bonne couleur, on saute cette ressource alors if (checkResourceColor && !Pixel.HasColor(resourceLocation, ResourceColor, GameHandle)) { continue; } resourceLocations.Add(resourceLocation); } // si ressource(s) trouvée(s) if (resourceLocations.Count > 0) { // affichage des positions des ressources sur la Minimap foreach (Point loc in resourceLocations) { Minimap.NewPin(MinimapPictureBox, GamePanel.Size, loc, Minimap.ResourcePinColor); } // Au boulot ! foreach (Point location in resourceLocations) { _pauseEvent.WaitOne(); if (_shutdownEvent.WaitOne(0)) { break; } // vérification de la connexion if (!Connection.State()) { Log.Error("Connexion perdue"); Suspend(); break; } // on s'assure que toutes les fenêtres popup sont fermés CheckPopUps(); // on collecte/récolte la ressource si possible if (location.X > 0 && location.Y > 0) { Log.Debug("Collecting Resource (X: " + location.X + " Y: " + location.Y + ")"); FakeClick.ClickOnPoint(GameHandle, location); Wait(Job.MaxCollectTime); Minimap.RemovePin(MinimapPictureBox, GamePanel.Size, location); Job.CollectedResourceCount++; } // on vérifie si un combat est en cours CheckFight(); } } } catch (Exception ex) { Log.Debug("Execption occured : " + ex.Message); } if (!_shutdownEvent.WaitOne(0)) // si le bot n'a pas été arrêté { Log.Debug("CollectedResourceCount : " + Job.CollectedResourceCount); Log.Divider(Log.Level.Debug); } }
public Pixel(Pixel pixel) { x = pixel.X; y = pixel.Y; }
protected sealed override Pixel ProcessPixel(Pixel original, LighteningParameters parameters) { return(original * parameters.Coefficient); }
private static double CalcColor(Pixel pixel) => (0.299 * pixel.R + 0.587 * pixel.G + 0.114 * pixel.B) / 255;
public InMaskPixel(Pixel pixel, int x, int y) { DecoratedPixel = pixel; MaskX = x; MaskY = y; }
/** * Checks a given coordinate to see if it is surrounded by a given pixel, usually air. */ public bool isSurroundedByPixel(Pixel checkPixel, int checkDistance, SurroundCheckType checkType, Random rand, int x, int y, int z) { switch (checkType) { case SurroundCheckType.FULL: // Checks the entire radius around the coord. for (int ix = -checkDistance; ix <= checkDistance; ix++) { for (int iz = -checkDistance; iz <= checkDistance; iz++) { if (x == ix && z == iz) { continue; } if (this.world.getPixelState(new PixelPos(x + ix, y, z + iz)) != checkPixel) { return(false); } } } break; case SurroundCheckType.CARDINAL: // Checks the N/E/S/W directions around the coord. for (int i = checkDistance; i > 0; i--) { if (this.world.getPixelState(new PixelPos(x, y, z + i)) != checkPixel) { return(false); } if (this.world.getPixelState(new PixelPos(x, y, z - i)) != checkPixel) { return(false); } if (this.world.getPixelState(new PixelPos(x + i, y, z)) != checkPixel) { return(false); } if (this.world.getPixelState(new PixelPos(x - i, y, z)) != checkPixel) { return(false); } } break; case SurroundCheckType.ORDINAL: // Checks the NE/SE/SW/NW directions around the coord. for (int i = checkDistance; i > 0; i--) { if (this.world.getPixelState(new PixelPos(x + i, y, z + i)) != checkPixel) { return(false); } if (this.world.getPixelState(new PixelPos(x + i, y, z - i)) != checkPixel) { return(false); } if (this.world.getPixelState(new PixelPos(x - i, y, z + i)) != checkPixel) { return(false); } if (this.world.getPixelState(new PixelPos(x - i, y, z - i)) != checkPixel) { return(false); } } break; case SurroundCheckType.UP: // Checks above coord. Pixel b; for (int i = checkDistance; i > 0; i--) { b = this.world.getPixelState(new PixelPos(x, y + i, z)); if (b != checkPixel) { return(false); } } break; default: break; } return(true); }
void SetPixel(int x, int y, Pixel p) { m_pixels[y * m_x_dims + x] = p; }
public void setDoublePlant(PixelPos lowerPos, Pixel doublePlant) { this.setDoublePlant(lowerPos, doublePlant, 2); }
public SurfaceCanyon(BiomeConfig config, Pixel top, Pixel fill, int grassHeight) : base(config, top, fill) { grassRaise = grassHeight; }