Exemple #1
0
        public override void IterateSrcDestByRows(
            IterFuncSrcDest pixelFunc,
            ScanningOrder scanOrder)
        {
            //PixelRgn srcPR = new PixelRgn(_drawable, _rectangle, false, false);
            //PixelRgn destPR = new PixelRgn(_drawable, _rectangle, true, true);

            //_imageBuffer = new byte[_rectangle.Width * _rectangle.Height * _drawable.Bpp];

            initBuffer();

            int bufferIndexY = 0;
            int rowstride = _rectangle.Width * _drawable.Bpp;
            //byte[] row = new byte[rowstride];
            Pixel tmpPixel = new Pixel(_drawable.Bpp);
            byte[] pixelBytes = new byte[_drawable.Bpp];

            int blockCount = 100;
            double progressPercentage = 0;
            double progressUnit = (double)blockCount / (double)_rectangle.Height;

            for (int y = _rectangle.Y1; y < _rectangle.Y2;
                y++, bufferIndexY += rowstride)
            {
                //Array.Copy(_imageBuffer, bufferIndexY, row, 0, rowstride);
                //Pixel[] pixelRow = srcPR.GetRow(_rectangle.X1, y, _rectangle.Width);
                //Pixel[] row = srcPR.GetRow(_rectangle.X1, y, srcPR.W);
                for (int x = 0, bufferIndex = bufferIndexY; x < _rectangle.Width;
                    x++, bufferIndex += _drawable.Bpp)
                {
                    // setPixel(x, y, pixelFunc(pixelRow[x]));

                    tmpPixel.CopyFrom(_imageBuffer, bufferIndex);
                    tmpPixel.X = x; tmpPixel.Y = y;
                    tmpPixel = pixelFunc(tmpPixel);
                    tmpPixel.CopyTo(_imageBuffer, bufferIndex);
                }
                if ((y % blockCount) == 0) {
                    progressPercentage += progressUnit;
                    Progress.Update(progressPercentage);
                }
            }
            flushBuffer();

            //_drawable.Flush();
            //_drawable.MergeShadow(true);
            //_drawable.Update(_rectangle);
        }
Exemple #2
0
        public override void IterateSrcDestDirect(
            IterFuncSrcDest pixelFunc,
            ScanningOrder scanOrder)
        {
            //// TODO: it should be: PixelFetcher(_drawable, true) to support undo
            //// but for now it doesn't work
            //using (PixelFetcher pf = new PixelFetcher(_drawable, false)) {
            //    foreach (Coordinate<int> coords in scanFunc(Width, Height)) {
            //        int y = _rectangle.Y1 + coords.Y;
            //        int x = _rectangle.X1 + coords.X;
            //        pf[y, x] = pixelFunc(pf[y, x]);
            //    }
            //}
            //_drawable.Flush();
            ////_drawable.MergeShadow(true);
            //_drawable.Update(_rectangle);

            //foreach (Coordinate<int> coords in scanFunc(Width, Height)) {
            //    int y = _rectangle.Y1 + coords.Y;
            //    int x = _rectangle.X1 + coords.X;
            //    //if (y % 10 == 0) { Console.WriteLine("[y,x]: {0}, {1}", y, x); }
            //    putPixel(x, y, pixelFunc(getPixel(x, y)));
            //}

            initBuffer();

            // Note: getting coords using iterator or calling next() is almost
            // the same in speed, although using next() allows better handling
            // progess updates.

            int x = 0;
            int y = 0;

            //// loop with progress count using next()
            scanOrder.init(Width, Height);
            IEnumerator<Coordinate<int>> coordsEnum = scanOrder.getCoordsEnumerable().GetEnumerator();
            // calulate a reasonable progress update count
            int blockCount = Math.Max((int)Math.Ceiling(
                Math.Ceiling(Math.Sqrt(Width * Height)) / 10.0), 1);
            int blockSize = (int)Math.Ceiling(Height * Width / (double)blockCount);
            double progressPercentage = 0;
            double progressUnit = 1.0 / (double)blockCount;
            for (int i = 0; i < blockCount; i++) {
                for (int block = 0; block < blockSize; block++) {
                    //if (scanOrder.hasNext()) {
                    if (coordsEnum.MoveNext()) {
                        x = coordsEnum.Current.X;
                        y = coordsEnum.Current.Y;
                        //scanOrder.next();
                        //x = scanOrder.CurrentX;
                        //y = scanOrder.CurrentY;
                        setPixel(x, y, pixelFunc(getPixel(x, y)));
                    } else {
                        break;
                    }
                }
                progressPercentage += progressUnit;
                Progress.Update(progressPercentage);
            }

            //scanOrder.init(Width, Height);
            //int blockCount = 100;
            //int blockSize = Width * Height / blockCount;
            //double progressPercentage = 0;
            //double progressUnit = 1.0 / (double)blockCount;
            //int i = 0;
            //for (scanOrder.init(Width, Height); scanOrder.hasNext(); scanOrder.next(out x, out y)) {
            //    setPixel(x, y, pixelFunc(getPixel(x, y)));
            //    if ((i++ % blockSize) == 0) {
            //        progressPercentage += progressUnit;
            //        Progress.Update(progressPercentage);
            //    }
            //}

            // loop without progress count using next()
            //for (scanOrder.init(Width, Height); scanOrder.hasNext(); scanOrder.next(out x, out y)) {
            //    setPixel(x, y, pixelFunc(getPixel(x, y)));
            //}

            // loop without progress count using iterator
            //foreach (Coordinate<int> coords in scanOrder.getCoordsEnumerable(Width, Height)) {
            //    setPixel(coords.X, coords.Y, pixelFunc(getPixel(coords.X, coords.Y)));
            //}

            flushBuffer();

            //PixelRgn srcPR = new PixelRgn(_drawable, _rectangle, false, false);
            //PixelRgn destPR = new PixelRgn(_drawable, _rectangle, true, true);

            //foreach (Coordinate<int> coords in scanFunc(Width, Height)) {
            //    int y = _rectangle.Y1 + coords.Y;
            //    int x = _rectangle.X1 + coords.X;
            //    //rgn.GetPixel(px.Bytes, x, y);
            //    srcPR.GetPixel(byteBuf, x, y);
            //    px.Bytes = byteBuf;
            //    px.X = x; px.Y = y;
            //    px = pixelFunc(px);
            //    destPR.SetPixel(px.Bytes, x, y);
            //}
            //_drawable.Flush();
            //_drawable.MergeShadow(true);
            //_drawable.Update(_rectangle);
        }
Exemple #3
0
 /// <summary>
 /// Iterate over all image pixels with no explicit order and modify
 /// each pixel with given function.
 /// </summary>
 /// <param name="pixelFunc">Function to modify pixels</param>
 //public abstract void IterateSrcDestNoOrder(
 //    IterFuncSrcDest pixelFunc);
 /// <summary>
 /// Iterate over all image pixels using given scanning order
 /// and modify each pixel with given function. Use direct access
 /// to image pixels.
 /// </summary>
 /// <param name="pixelFunc">Function to modify pixels</param>
 /// <param name="scanOrder">Scanning order</param>
 public abstract void IterateSrcDestDirect(
     IterFuncSrcDest pixelFunc,
     ScanningOrder scanOrder);