Esempio n. 1
0
        private void calculateDCTForBlock(YCrCb[,] matrix, int x, int y)
        {
            var tempMatrix = new YCrCb[BlockSize,BlockSize];
            for (int k = 0; k < BlockSize; k++)
            {
                for (int l = 0; l < BlockSize; l++)
                {
                    double sumY = 0, sumCr = 0, sumCb = 0;
                    for (int i = 0; i < BlockSize; i++)
                    {
                        for (int j = 0; j < BlockSize; j++)
                        {
                            sumY += coefficient(k)*coefficient(l)*matrix[i + x, j + y].Y*calculateCosine(k, i)*
                                    calculateCosine(l, j)/4;
                            sumCr += coefficient(k)*coefficient(l)*matrix[i + x, j + y].Cr*calculateCosine(k, i)*
                                     calculateCosine(l, j)/4;
                            sumCb += coefficient(k)*coefficient(l)*matrix[i + x, j + y].Cb*calculateCosine(k, i)*
                                     calculateCosine(l, j)/4;
                        }
                    }

                    tempMatrix[k, l].Y = Math.Round(sumY, 1);
                    tempMatrix[k, l].Cr = Math.Round(sumCr, 2);
                    tempMatrix[k, l].Cb = Math.Round(sumCb, 2);
                }
            }

            copyTempMatrixToRealMatrix(x, y, matrix, tempMatrix);
        }
        public static void PrintMatrix(string name, YCrCb[,] matrix)
        {
            Console.WriteLine(name + " Y ");
            for (int i = 0; i < matrix.GetLength(0); i++)
            {
                for (int j = 0; j < matrix.GetLength(1); j++)
                {
                    Console.Write((matrix[i, j].Y).ToString().PadLeft(6, ' '));
                }
                Console.WriteLine();
            }
            Console.WriteLine();

            //Console.WriteLine(name + " Cr ");
            //for (int i = 0; i < matrix.GetLength(0); i++)
            //{
            //    for (int j = 0; j < matrix.GetLength(1); j++)
            //    {
            //        Console.Write((matrix[i, j].Cr).ToString().PadLeft(10, ' '));
            //    }
            //    Console.WriteLine();
            //}
            //Console.WriteLine();

            //Console.WriteLine(name + " Cb ");
            //for (int i = 0; i < matrix.GetLength(0); i++)
            //{
            //    for (int j = 0; j < matrix.GetLength(1); j++)
            //    {
            //        Console.Write((matrix[i, j].Cb).ToString().PadLeft(10, ' '));
            //    }
            //    Console.WriteLine();
            //}
            //Console.WriteLine();
        }
Esempio n. 3
0
 public static RGB Parse(YCrCb yCrCb)
 {
     return new RGB
                {
                    R = calculateRed(yCrCb),
                    B = calculateBlue(yCrCb),
                    G = calculateGreen(yCrCb)
                };
 }
Esempio n. 4
0
 public void Supersample(YCrCb[,] matrix)
 {
     for (int i = 0; i < matrix.GetLength(0); i++)
     {
         for (int j = 0; j < matrix.GetLength(1); j++)
         {
             matrix[i, j].Y += 128;
             matrix[i, j].Cr += 128;
             matrix[i, j].Cb += 128;
         }
     }
 }
Esempio n. 5
0
        private YCrCb[,] convertToYCrCb(double[,] matrix)
        {
            var convertedMatrix = new YCrCb[8,8];
            for (int m = 0; m < 8; m++)
            {
                for (int n = 0; n < 8; n++)
                {
                    convertedMatrix[m, n] = new YCrCb {Y = matrix[m, n]};
                }
            }

            return convertedMatrix;
        }
Esempio n. 6
0
        private double[,] convertToDouble(YCrCb[,] expectedMatrix)
        {
            var convertedMatrix = new double[8,8];
            for (int m = 0; m < 8; m++)
            {
                for (int n = 0; n < 8; n++)
                {
                    convertedMatrix[m, n] = expectedMatrix[m, n].Y;
                }
            }

            return convertedMatrix;
        }
Esempio n. 7
0
        public void CalculateIDCT(YCrCb[,] matrix)
        {
            int width = matrix.GetLength(0);
            int height = matrix.GetLength(1);

            for (int x = 0; x < width; x = x + BlockSize)
            {
                for (int y = 0; y < height; y = y + BlockSize)
                {
                    calculateIDCTForBlock(matrix, x, y);
                }
            }
        }
 private int bitsPerNonZeroDCTCoefficient(YCrCb[,] matrix)
 {
     int count = 0;
     for (int i = 0; i < matrix.GetLength(0); i++)
     {
         for (int j = 0; j < matrix.GetLength(1); j++)
         {
             if (matrix[i, j].Y != 0 && matrix[i, j].Y != 1)
             {
                 count++;
             }
         }
     }
     return count;
 }
Esempio n. 9
0
        public static YCrCb[,] Parse(RGB[,] rgb)
        {
            int m = rgb.GetLength(0);
            int n = rgb.GetLength(1);
            var matrix = new YCrCb[m, n];

            for (int i = 0; i < m; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    matrix[i, j] = Parse(rgb[i, j]);
                }
            }
            return matrix;
        }
        public List<Point> Permutation(YCrCb[,] matrix)
        {
            var points = new List<Point>();

            for (int i = 0; i < matrix.GetLength(0); i++)
            {
                for (int j = 0; j < matrix.GetLength(1); j++)
                {
                    if (matrix[i, j].Y != 0 && matrix[i, j].Y != 1)
                    {
                        points.Add(new Point(i, j));
                    }
                }
            }
            return points;
        }
Esempio n. 11
0
        public static RGB[,] Parse(YCrCb[,] yCrCb)
        {
            int m = yCrCb.GetLength(0);
            int n = yCrCb.GetLength(1);
            var matrix = new RGB[m, n];

            for (int i = 0; i < m; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    matrix[i, j] = Parse(yCrCb[i, j]);
                }
            }

            return matrix;
        }
Esempio n. 12
0
        public void ApplyQuantization(YCrCb[,] matrix, int qualityFactor)
        {
            int i, j, k, l;
            int[,] qualityLuminanceMatrix = generateQualityFactorLuminanceMatrix(qualityFactor);
            int[,] qualityChrominanceMatrix = generateQualityFactorChrominanceMatrix(qualityFactor);

            for (i = 0; i < matrix.GetLength(0); i++)
            {
                k = i % 8;
                for (j = 0; j < matrix.GetLength(1); j++)
                {
                    l = j % 8;
                    matrix[i, j].Y = Math.Round(matrix[i, j].Y / qualityLuminanceMatrix[k, l]);
                    matrix[i, j].Cr = Math.Round(matrix[i, j].Cr / qualityChrominanceMatrix[k, l]);
                    matrix[i, j].Cb = Math.Round(matrix[i, j].Cb / qualityChrominanceMatrix[k, l]);
                }
            }
        }
        public void HideMessage(YCrCb[,] matrix, byte[] message)
        {
            if (bitsPerNonZeroDCTCoefficient(matrix) - 32 < message.Length * 8)
                throw new ArgumentException("Message too long to be embedded.");

            var path = Permutation(matrix);
            var bitsFromSizeField = new BitArray(BitConverter.GetBytes(message.Length * 8));
            int i = 0;
            foreach (var bit in bitsFromSizeField)
            {
                matrix[path[i].X, path[i].Y].Y = calculateLSB(matrix[path[i].X, path[i].Y].Y, Convert.ToInt32(bit));
                i++;
            }

            var bitsFromDataField = new BitArray(message);
            i = 32;
            foreach (var bit in bitsFromDataField)
            {
                matrix[path[i].X, path[i].Y].Y = calculateLSB(matrix[path[i].X, path[i].Y].Y, Convert.ToInt32(bit));
                i++;
            }
        }
        public byte[] ExtractMessage(YCrCb[,] matrix)
        {
            var path = Permutation(matrix);
            var pathIndex = 0;
            var bitsFromSizeField = new BitArray(32);
            for (pathIndex = 0; pathIndex < bitsFromSizeField.Length; pathIndex++)
            {
                int lsb = ((int) matrix[path[pathIndex].X, path[pathIndex].Y].Y)%2;
                bitsFromSizeField.Set(pathIndex, lsb != 0);
            }
            var bytesFromSizeField = new byte[4];
            bitsFromSizeField.CopyTo(bytesFromSizeField, 0);

            int sizeField = BitConverter.ToInt32(bytesFromSizeField, 0);

            var bitsFromDataField = new BitArray(sizeField);
            for (int i = 0; i < sizeField; i++, pathIndex++)
                bitsFromDataField.Set(i, ((int)matrix[path[pathIndex].X, path[pathIndex].Y].Y) % 2 != 0);

            var bytesFromDataField = new byte[(int)Math.Ceiling(sizeField / 8.0)];
            bitsFromDataField.CopyTo(bytesFromDataField, 0);

            return bytesFromDataField;
        }
Esempio n. 15
0
 private static double calculateBlue(YCrCb yCrCb)
 {
     return Math.Round(yCrCb.Y + 1.772*(yCrCb.Cb - 128)).ToByteBounds();
 }
Esempio n. 16
0
 private static double calculateGreen(YCrCb yCrCb)
 {
     return  Math.Round(yCrCb.Y - 0.34414*(yCrCb.Cb - 128) - 0.71414*(yCrCb.Cr - 128)).ToByteBounds();
 }
Esempio n. 17
0
 private static double calculateRed(YCrCb yCrCb)
 {
     return  Math.Round(yCrCb.Y + 1.402 * (yCrCb.Cr - 128)).ToByteBounds() ;
 }
Esempio n. 18
0
 private void copyTempMatrixToRealMatrix(int x, int y, YCrCb[,] matrix, YCrCb[,] tempMatrix)
 {
     for (int i = 0; i < BlockSize; i++)
     {
         for (int j = 0; j < BlockSize; j++)
         {
             matrix[i + x, j + y].Y = tempMatrix[i, j].Y;
             matrix[i + x, j + y].Cb = tempMatrix[i, j].Cb;
             matrix[i + x, j + y].Cr = tempMatrix[i, j].Cr;
         }
     }
 }