/*
        Returns the amount of error compared to a given block at the current position
            */
        public double getErrorForPosition(double[,] image, Block comparison, int xPos, int yPos, int channel) {
            xPos -= 4;
            yPos -= 4;

            double error = 0;
            double pixelValue;
            double currentError;
            Color color = new Color();
            switch (channel)
            {
                case 1:
                    YerrorBlock = new Block();
                    break;
                case 2:
                    CberrorBlock = new Block();
                    break;
                case 3:
                    CrerrorBlock = new Block();
                    break;
            }
            
            for (int y=yPos; y<yPos+8; y++) {
                for (int x=xPos; x<xPos+8; x++) {
                    //if out of bounds, treat as a value of zero
                    if (y >= image.GetLength(1) || x >= image.GetLength(0)||x<0||y<0) {
                        switch (channel)
                        {
                            case 1:
                                YerrorBlock.set(x - xPos, y - yPos, Math.Round(0 - comparison.get(x - xPos, y - yPos)));
                                break;
                            case 2:
                                CberrorBlock.set(x - xPos, y - yPos, Math.Round((0 - comparison.get(x - xPos, y - yPos))));
                                break;
                            case 3:
                                CrerrorBlock.set(x - xPos, y - yPos, Math.Round((0 - comparison.get(x - xPos, y - yPos))));
                                break;
                        }
                        
                        error += Math.Abs(0 - comparison.get(x - xPos, y - yPos));
                        continue;
                    }
                    currentError = image[x,y]-comparison.get(x-xPos, y-yPos);
                    error += Math.Abs(currentError);
                    switch (channel)
                    {
                        case 1:
                            YerrorBlock.set(x - xPos, y - yPos, Math.Round(currentError));
                            break;
                        case 2:
                            CberrorBlock.set(x - xPos, y - yPos, Math.Round(currentError));
                            break;
                        case 3:
                            CrerrorBlock.set(x - xPos, y - yPos, Math.Round(currentError));
                            break;
                    }                    
                }
            }
                       
            if (xPos == 3 && yPos == 0)
            {
                //Debug.WriteLine("----------------------------ErrorBlock-----------------------------------");
                for (int q = 0; q < 8; q++)
                {
                    for (int w = 0; w < 8; w++)
                    {
                        //Debug.Write(errorBlock.get(q, w) + ",");
                        //Debug.Write(comparison.get(q, w) + ",");
                    }
                   // Debug.WriteLine("");
                }
               // Debug.WriteLine("----------------------------------------------------------------------------------------------");
            }

            error /= 64;

           // Debug.WriteLine("Total error = "+error);

            return error;
        }
        /*
        Returns the amount of error compared to a given block at the current position
            */
        public void getOriginalFromError(double[,] image, Block errorBlock, int xPos, int yPos, int channel)
        {
            xPos -= 4;
            yPos -= 4;

            double error = 0;
            double pixelValue;
            double currentError;
            Color color = new Color();
            switch (channel)
            {
                case 1:
                    YpostBlock = new Block();
                    break;
                case 2:
                    CbpostBlock = new Block();
                    break;
                case 3:
                    CrpostBlock = new Block();
                    break;
            }

            for (int y = yPos; y < yPos + 8; y++)
            {
                for (int x = xPos; x < xPos + 8; x++)
                {
                    //if out of bounds, treat as a value of zero
                    if (y >= image.GetLength(1) || x >= image.GetLength(0) || x < 0 || y < 0)
                    {
                        switch (channel)
                        {
                            case 1:
                                YpostBlock.set(x - xPos, y - yPos, Math.Round(Math.Abs(0 + errorBlock.get(x - xPos, y - yPos))));
                                break;
                            case 2:
                                CbpostBlock.set(x - xPos, y - yPos, Math.Round(Math.Abs(0 + errorBlock.get(x - xPos, y - yPos))));
                                break;
                            case 3:
                                CrpostBlock.set(x - xPos, y - yPos, Math.Round(Math.Abs(0 + errorBlock.get(x - xPos, y - yPos))));
                                break;
                        }                        
                        continue;
                    }
                    currentError = Math.Abs(image[x, y] + errorBlock.get(x - xPos, y - yPos));
                    switch (channel)
                    {
                        case 1:
                            YerrorBlock.set(x - xPos, y - yPos, Math.Round(currentError));
                            break;
                        case 2:
                            CbpostBlock.set(x - xPos, y - yPos, Math.Round(currentError));
                            break;
                        case 3:
                            CrpostBlock.set(x - xPos, y - yPos, Math.Round(currentError));
                            break;
                    }
                }
            }
        }
Esempio n. 3
0
        /*
        undoes zig zag on an int array, and outputs the original 8x8 block
            */
        public Block undoZigZag(int[] array) {
            Block block = new Block();

            int arrayPos = 0;
            int yMove = -1;
            int xMove = 1;
            int x = 0;
            int y = 0;

            block.set(x, y, array[arrayPos++]);

            for (int level = 0; level < 8; level++)
            {

                for (int depth = 0; depth < level; depth++)
                {
                    x += xMove;
                    y += yMove;

                    block.set(x, y, array[arrayPos++]);
                }

                if (level == 7) break;

                if (xMove < 0) y++; else x++;

                block.set(x, y, array[arrayPos++]);

                yMove *= -1;
                xMove *= -1;
            }

            yMove *= -1;
            xMove *= -1;

            if (xMove < 0) y++; else x++;

            block.set(x, y, array[arrayPos++]);

            for (int level = 6; level > 0; level--)
            {

                for (int depth = level; depth > 0; depth--)
                {
                    x += xMove;
                    y += yMove;

                    block.set(x, y, array[arrayPos++]);
                }

                if (xMove < 0) x++; else y++;

                block.set(x, y, array[arrayPos++]);

                yMove *= -1;
                xMove *= -1;
            }
            

            return block;
        }
Esempio n. 4
0
        /*
        Multiplies the values of a quantized block by a quantization table to undo quantization. returns the outcome
            */
        public Block RemoveQuantization(Block block, int[,] table)
        {
            Block quantizedBlock = new Block();
            for (int y = 0; y < 8; y++)
            {
                for (int x = 0; x < 8; x++)
                {
                    quantizedBlock.set(x, y, block.get(x, y) * table[x, y]);
                }
            }

            return quantizedBlock;
        }
Esempio n. 5
0
        /*
        Divides the values of the block by a passed quantization table, and returns the outcome
            */
        public Block applyQuantization(Block block, int[,] table) {
            Block quantizedBlock = new Block();
            for (int y=0; y<8; y++) {
                for (int x=0; x<8; x++) {
                    quantizedBlock.set(x,y,Math.Round((double)block.get(x, y) / table[x, y]));
                }
            }

            return quantizedBlock;
        }
Esempio n. 6
0
 /*
 Generates an 8x8 block from a position 
     */
 public Block generateBlock(double[,] fullSize, int xPosition, int yPosition) {
     Block block = new Block();
     
     for (int y=yPosition; y<yPosition+8; y++) {
         for (int x=xPosition; x<xPosition+8; x++) {
             if (x < fullSize.GetLength(0) && y < fullSize.GetLength(1))
             {
                 block.set(x-xPosition,y-yPosition,fullSize[x,y]);
             }
             else {
                 block.set(x - xPosition, y - yPosition, 0.0);
             }
         }
     }
     return block;
 }