Java实现【快速离散余弦变换FDCT】参考：《图像数字水印的JAVA实现 刘剑鸣 著》

最新推荐文章于 2024-06-17 11:22:32 发布
最新推荐文章于 2024-06-17 11:22:32 发布
阅读量624 收藏 3
点赞数
分类专栏： java图像 文章标签： java 算法

工具类：ImageUtil.java    MathTool.java

[java]  view plain copy
  1. package com.zeph.watermark.util;  
  2.   
  3. public class MathTool {  
  4.     public static double[][] intToDoubleMatrix(int[][] input) {  
  5.         int height = input.length;  
  6.         int width = input[0].length;  
  7.         double[][] output = new double[height][width];  
  8.         for (int i = 0; i < height; i++) {  
  9.             // 列  
  10.             for (int j = 0; j < width; j++) {  
  11.                 // 行  
  12.                 output[i][j] = Double.valueOf(String.valueOf(input[i][j]));  
  13.                 System.out.print(output[i][j]);  
  14.             }  
  15.             System.out.println();  
  16.         }  
  17.         return output;  
  18.     }  
  19.   
  20.     public static double[] intToDoubleArray(int[] input) {  
  21.         int length = input.length;  
  22.         double[] output = new double[length];  
  23.         for (int i = 0; i < length; i++)  
  24.             output[i] = Double.valueOf(String.valueOf(input[i]));  
  25.         return output;  
  26.     }  
  27.   
  28.     public static void main(String[] args) {  
  29.         int[][] test = { { 4, 5, 6 }, { 1, 2, 3 } };  
  30.         MathTool.intToDoubleMatrix(test);  
  31.     }  
  32. }  
[java]  view plain copy
  1. package com.zeph.watermark.util;  
  2.   
  3. public class MathTool {  
  4.     public static double[][] intToDoubleMatrix(int[][] input) {  
  5.         int height = input.length;  
  6.         int width = input[0].length;  
  7.         double[][] output = new double[height][width];  
  8.         for (int i = 0; i < height; i++) {  
  9.             // 列  
  10.             for (int j = 0; j < width; j++) {  
  11.                 // 行  
  12.                 output[i][j] = Double.valueOf(String.valueOf(input[i][j]));  
  13.                 System.out.print(output[i][j]);  
  14.             }  
  15.             System.out.println();  
  16.         }  
  17.         return output;  
  18.     }  
  19.   
  20.     public static double[] intToDoubleArray(int[] input) {  
  21.         int length = input.length;  
  22.         double[] output = new double[length];  
  23.         for (int i = 0; i < length; i++)  
  24.             output[i] = Double.valueOf(String.valueOf(input[i]));  
  25.         return output;  
  26.     }  
  27.   
  28.     public static void main(String[] args) {  
  29.         int[][] test = { { 4, 5, 6 }, { 1, 2, 3 } };  
  30.         MathTool.intToDoubleMatrix(test);  
  31.     }  
  32. }  

[java]  view plain copy
  1. package com.zeph.watermark.util;  
  2.   
  3. import java.awt.image.BufferedImage;  
  4. import java.awt.image.WritableRaster;  
  5. import java.io.File;  
  6. import java.io.IOException;  
  7.   
  8. import javax.imageio.ImageIO;  
  9.   
  10. public class ImageUtil {  
  11.     /** 
  12.      * 获取图片 
  13.      *  
  14.      * @param filepath 
  15.      * @return 
  16.      */  
  17.     public static BufferedImage getImage(String filepath) {  
  18.         BufferedImage image = null;  
  19.         File file = new File(filepath);  
  20.         try {  
  21.             image = ImageIO.read(file);  
  22.         } catch (IOException e) {  
  23.             e.printStackTrace();  
  24.         }  
  25.         return image;  
  26.     }  
  27.   
  28.     /** 
  29.      * 获取图像文件的像素（图片转换为像素） 
  30.      *  
  31.      * @param filepath 
  32.      * @param format 
  33.      */  
  34.     public int[] getImagePixels(String filepath) {  
  35.         BufferedImage image = null;  
  36.         File file = new File(filepath);  
  37.         try {  
  38.             image = ImageIO.read(file);  
  39.         } catch (IOException e) {  
  40.             e.printStackTrace();  
  41.         }  
  42.         WritableRaster raster = image.getRaster();  
  43.         // 得到图像的宽度  
  44.         int width = raster.getWidth();  
  45.         // 得到图像的高度  
  46.         int height = raster.getHeight();  
  47.         // RGB格式图像文件每一个点的颜色由红、绿、兰三种颜色构成，即实际图像可为3层，  
  48.         // 分别为R，G，B层，因此分解后的文件象素是实际坐标高度和宽度的三倍。  
  49.         int[] pixels = new int[3 * width * height];  
  50.         // 读取坐标的范围是从(0,0)坐标开始宽width,高height  
  51.         raster.getPixels(0, 0, width, height, pixels);  
  52.         return pixels;  
  53.     }  
  54.   
  55.     /** 
  56.      * 像素转换成图像文件 
  57.      *  
  58.      * @param result 
  59.      * @param width 
  60.      * @param height 
  61.      * @param filepath 
  62.      * @param format 
  63.      */  
  64.     public static void setImage(double[] result, int width, int height,  
  65.             String filepath, String format, int type) {  
  66.         BufferedImage outImage = new BufferedImage(width, height, type);  
  67.         WritableRaster outRaster = outImage.getRaster();  
  68.         outRaster.setPixels(0, 0, width, height, result);  
  69.         // 图像文件的写入  
  70.         File outFile = new File(filepath);  
  71.         try {  
  72.             ImageIO.write(outImage, format, outFile);  
  73.         } catch (IOException e) {  
  74.             e.printStackTrace();  
  75.         }  
  76.     }  
  77.   
  78.     /** 
  79.      * 一维数组转为二维数组 
  80.      *  
  81.      * @param m 
  82.      * @param width 
  83.      * @param height 
  84.      * @return 
  85.      */  
  86.     public static int[][] arrayToMatrix(int[] m, int width, int height) {  
  87.         int[][] result = new int[height][width];  
  88.         for (int i = 0; i < height; i++) {  
  89.             for (int j = 0; j < width; j++) {  
  90.                 int p = j * height + i;  
  91.                 result[i][j] = m[p];  
  92.             }  
  93.         }  
  94.         return result;  
  95.     }  
  96.   
  97.     /** 
  98.      * 一维数组转换为三维数组 
  99.      *  
  100.      * @param pixels 
  101.      * @param width 
  102.      * @param height 
  103.      * @return 
  104.      */  
  105.     public static int[][][] getRGBArrayToMatrix(int[] pixels, int width,  
  106.             int height) {  
  107.         // 已知有3个二维数组组成分别代表RGB  
  108.         int[][][] result = new int[3][height][width];  
  109.         int[][] temp = new int[3][width * height];  
  110.         for (int i = 0; i < pixels.length; i++) {  
  111.             int m = i / 3;  
  112.             int n = i % 3;  
  113.             temp[n][m] = pixels[i];  
  114.         }  
  115.         result[0] = arrayToMatrix(temp[0], width, height);  
  116.         result[1] = arrayToMatrix(temp[1], width, height);  
  117.         result[2] = arrayToMatrix(temp[2], width, height);  
  118.         return result;  
  119.     }  
  120.   
  121.     /** 
  122.      * 二维数组转为一维数组 
  123.      *  
  124.      * @param m 
  125.      * @return 
  126.      */  
  127.     public static double[] matrixToArray(double[][] m) {  
  128.         int p = m.length * m[0].length;  
  129.         double[] result = new double[p];  
  130.         for (int i = 0; i < m.length; i++) {  
  131.             for (int j = 0; j < m[i].length; j++) {  
  132.                 int q = j * m.length + i;  
  133.                 result[q] = m[i][j];  
  134.             }  
  135.         }  
  136.         return result;  
  137.     }  
  138.   
  139.     /** 
  140.      * 三维数组转为一维数组 
  141.      *  
  142.      * @param m 
  143.      * @return 
  144.      */  
  145.     public static double[] getRGBMatrixToArray(double[][][] m) {  
  146.         int width = m[0].length;  
  147.         int height = m[0][0].length;  
  148.         int len = width * height;  
  149.         double[] result = new double[3 * len];  
  150.         double[][] temp = new double[3][len];  
  151.         temp[0] = matrixToArray(m[0]);  
  152.         temp[1] = matrixToArray(m[1]);  
  153.         temp[2] = matrixToArray(m[2]);  
  154.         for (int i = 0; i < 3; i++) {  
  155.             for (int j = 0; j < temp[i].length; j++)  
  156.                 result[3 * j + i] = temp[i][j];  
  157.         }  
  158.         return result;  
  159.     }  
  160. }  
[java]  view plain copy
  1. package com.zeph.watermark.util;  
  2.   
  3. import java.awt.image.BufferedImage;  
  4. import java.awt.image.WritableRaster;  
  5. import java.io.File;  
  6. import java.io.IOException;  
  7.   
  8. import javax.imageio.ImageIO;  
  9.   
  10. public class ImageUtil {  
  11.     /** 
  12.      * 获取图片 
  13.      *  
  14.      * @param filepath 
  15.      * @return 
  16.      */  
  17.     public static BufferedImage getImage(String filepath) {  
  18.         BufferedImage image = null;  
  19.         File file = new File(filepath);  
  20.         try {  
  21.             image = ImageIO.read(file);  
  22.         } catch (IOException e) {  
  23.             e.printStackTrace();  
  24.         }  
  25.         return image;  
  26.     }  
  27.   
  28.     /** 
  29.      * 获取图像文件的像素（图片转换为像素） 
  30.      *  
  31.      * @param filepath 
  32.      * @param format 
  33.      */  
  34.     public int[] getImagePixels(String filepath) {  
  35.         BufferedImage image = null;  
  36.         File file = new File(filepath);  
  37.         try {  
  38.             image = ImageIO.read(file);  
  39.         } catch (IOException e) {  
  40.             e.printStackTrace();  
  41.         }  
  42.         WritableRaster raster = image.getRaster();  
  43.         // 得到图像的宽度  
  44.         int width = raster.getWidth();  
  45.         // 得到图像的高度  
  46.         int height = raster.getHeight();  
  47.         // RGB格式图像文件每一个点的颜色由红、绿、兰三种颜色构成，即实际图像可为3层，  
  48.         // 分别为R，G，B层，因此分解后的文件象素是实际坐标高度和宽度的三倍。  
  49.         int[] pixels = new int[3 * width * height];  
  50.         // 读取坐标的范围是从(0,0)坐标开始宽width,高height  
  51.         raster.getPixels(0, 0, width, height, pixels);  
  52.         return pixels;  
  53.     }  
  54.   
  55.     /** 
  56.      * 像素转换成图像文件 
  57.      *  
  58.      * @param result 
  59.      * @param width 
  60.      * @param height 
  61.      * @param filepath 
  62.      * @param format 
  63.      */  
  64.     public static void setImage(double[] result, int width, int height,  
  65.             String filepath, String format, int type) {  
  66.         BufferedImage outImage = new BufferedImage(width, height, type);  
  67.         WritableRaster outRaster = outImage.getRaster();  
  68.         outRaster.setPixels(0, 0, width, height, result);  
  69.         // 图像文件的写入  
  70.         File outFile = new File(filepath);  
  71.         try {  
  72.             ImageIO.write(outImage, format, outFile);  
  73.         } catch (IOException e) {  
  74.             e.printStackTrace();  
  75.         }  
  76.     }  
  77.   
  78.     /** 
  79.      * 一维数组转为二维数组 
  80.      *  
  81.      * @param m 
  82.      * @param width 
  83.      * @param height 
  84.      * @return 
  85.      */  
  86.     public static int[][] arrayToMatrix(int[] m, int width, int height) {  
  87.         int[][] result = new int[height][width];  
  88.         for (int i = 0; i < height; i++) {  
  89.             for (int j = 0; j < width; j++) {  
  90.                 int p = j * height + i;  
  91.                 result[i][j] = m[p];  
  92.             }  
  93.         }  
  94.         return result;  
  95.     }  
  96.   
  97.     /** 
  98.      * 一维数组转换为三维数组 
  99.      *  
  100.      * @param pixels 
  101.      * @param width 
  102.      * @param height 
  103.      * @return 
  104.      */  
  105.     public static int[][][] getRGBArrayToMatrix(int[] pixels, int width,  
  106.             int height) {  
  107.         // 已知有3个二维数组组成分别代表RGB  
  108.         int[][][] result = new int[3][height][width];  
  109.         int[][] temp = new int[3][width * height];  
  110.         for (int i = 0; i < pixels.length; i++) {  
  111.             int m = i / 3;  
  112.             int n = i % 3;  
  113.             temp[n][m] = pixels[i];  
  114.         }  
  115.         result[0] = arrayToMatrix(temp[0], width, height);  
  116.         result[1] = arrayToMatrix(temp[1], width, height);  
  117.         result[2] = arrayToMatrix(temp[2], width, height);  
  118.         return result;  
  119.     }  
  120.   
  121.     /** 
  122.      * 二维数组转为一维数组 
  123.      *  
  124.      * @param m 
  125.      * @return 
  126.      */  
  127.     public static double[] matrixToArray(double[][] m) {  
  128.         int p = m.length * m[0].length;  
  129.         double[] result = new double[p];  
  130.         for (int i = 0; i < m.length; i++) {  
  131.             for (int j = 0; j < m[i].length; j++) {  
  132.                 int q = j * m.length + i;  
  133.                 result[q] = m[i][j];  
  134.             }  
  135.         }  
  136.         return result;  
  137.     }  
  138.   
  139.     /** 
  140.      * 三维数组转为一维数组 
  141.      *  
  142.      * @param m 
  143.      * @return 
  144.      */  
  145.     public static double[] getRGBMatrixToArray(double[][][] m) {  
  146.         int width = m[0].length;  
  147.         int height = m[0][0].length;  
  148.         int len = width * height;  
  149.         double[] result = new double[3 * len];  
  150.         double[][] temp = new double[3][len];  
  151.         temp[0] = matrixToArray(m[0]);  
  152.         temp[1] = matrixToArray(m[1]);  
  153.         temp[2] = matrixToArray(m[2]);  
  154.         for (int i = 0; i < 3; i++) {  
  155.             for (int j = 0; j < temp[i].length; j++)  
  156.                 result[3 * j + i] = temp[i][j];  
  157.         }  
  158.         return result;  
  159.     }  
  160. }  

实现类：Dct.java    FDct.java    IFDct.java    AddWatermark.java    ExtractWatermark.java

[java]  view plain copy
  1. package com.zeph.watermark.fdct;  
  2.   
  3. public interface Dct {  
  4.     static double C1 = 0.98078528, C2 = 0.923879532, C3 = 0.831469612,  
  5.             C4 = 0.707106781, C5 = 0.555570233, C6 = 0.382683432,  
  6.             C7 = 0.195090322;  
  7. }  
[java]  view plain copy
  1. package com.zeph.watermark.fdct;  
  2.   
  3. public interface Dct {  
  4.     static double C1 = 0.98078528, C2 = 0.923879532, C3 = 0.831469612,  
  5.             C4 = 0.707106781, C5 = 0.555570233, C6 = 0.382683432,  
  6.             C7 = 0.195090322;  
  7. }  

[java]  view plain copy
  1. package com.zeph.watermark.fdct;  
  2.   
  3. public class FDct implements Dct {  
  4.     public static double[][] fDctTransform(double[][] ablk) {  
  5.         double[][] blk = new double[8][8];  
  6.         for (int i = 0; i < 8; i++) {  
  7.             for (int j = 0; j < 8; j++) {  
  8.                 blk[i][j] = ablk[i][j];  
  9.             }  
  10.         }  
  11.         // 对行变换  
  12.         for (int i = 0; i <= 7; i++) {  
  13.             double S07, S16, S25, S34, S0734, S1625;  
  14.             double D07, D16, D25, D34, D0734, D1625;  
  15.             S07 = blk[i][0] + blk[i][7];  
  16.             S16 = blk[i][1] + blk[i][6];  
  17.             S25 = blk[i][2] + blk[i][5];  
  18.             S34 = blk[i][3] + blk[i][4];  
  19.             S0734 = S07 + S34;  
  20.             S1625 = S16 + S25;  
  21.             D07 = blk[i][0] - blk[i][7];  
  22.             D16 = blk[i][1] - blk[i][6];  
  23.             D25 = blk[i][2] - blk[i][5];  
  24.             D34 = blk[i][3] - blk[i][4];  
  25.             D0734 = S07 - S34;  
  26.             D1625 = S16 - S25;  
  27.             blk[i][0] = 0.5 * (C4 * (S0734 + S1625));  
  28.             blk[i][1] = 0.5 * (C1 * D07 + C3 * D16 + C5 * D25 + C7 * D34);  
  29.             blk[i][2] = 0.5 * (C2 * D0734 + C6 * D1625);  
  30.             blk[i][3] = 0.5 * (C3 * D07 - C7 * D16 - C1 * D25 - C5 * D34);  
  31.             blk[i][4] = 0.5 * (C4 * (S0734 - S1625));  
  32.             blk[i][5] = 0.5 * (C5 * D07 - C1 * D16 + C7 * D25 + C3 * D34);  
  33.             blk[i][6] = 0.5 * (C6 * D0734 - C2 * D1625);  
  34.             blk[i][7] = 0.5 * (C7 * D07 - C5 * D16 + C3 * D25 - C1 * D34);  
  35.         }  
  36.         // 对列变换  
  37.         for (int j = 0; j <= 7; j++) {  
  38.             double S07, S16, S25, S34, S0734, S1625;  
  39.             double D07, D16, D25, D34, D0734, D1625;  
  40.             S07 = blk[0][j] + blk[7][j];  
  41.             S16 = blk[1][j] + blk[6][j];  
  42.             S25 = blk[2][j] + blk[5][j];  
  43.             S34 = blk[3][j] + blk[4][j];  
  44.             S0734 = S07 + S34;  
  45.             S1625 = S16 + S25;  
  46.             D07 = blk[0][j] - blk[7][j];  
  47.             D16 = blk[1][j] - blk[6][j];  
  48.             D25 = blk[2][j] - blk[5][j];  
  49.             D34 = blk[3][j] - blk[4][j];  
  50.             D0734 = S07 - S34;  
  51.             D1625 = S16 - S25;  
  52.             blk[0][j] = 0.5 * (C4 * (S0734 + S1625));  
  53.             blk[1][j] = 0.5 * (C1 * D07 + C3 * D16 + C5 * D25 + C7 * D34);  
  54.             blk[2][j] = 0.5 * (C2 * D0734 + C6 * D1625);  
  55.             blk[3][j] = 0.5 * (C3 * D07 - C7 * D16 - C1 * D25 - C5 * D34);  
  56.             blk[4][j] = 0.5 * (C4 * (S0734 - S1625));  
  57.             blk[5][j] = 0.5 * (C5 * D07 - C1 * D16 + C7 * D25 + C3 * D34);  
  58.             blk[6][j] = 0.5 * (C6 * D0734 - C2 * D1625);  
  59.             blk[7][j] = 0.5 * (C7 * D07 - C5 * D16 + C3 * D25 - C1 * D34);  
  60.         }  
  61.         return blk;  
  62.     }  
  63. }  
[java]  view plain copy
  1. package com.zeph.watermark.fdct;  
  2.   
  3. public class FDct implements Dct {  
  4.     public static double[][] fDctTransform(double[][] ablk) {  
  5.         double[][] blk = new double[8][8];  
  6.         for (int i = 0; i < 8; i++) {  
  7.             for (int j = 0; j < 8; j++) {  
  8.                 blk[i][j] = ablk[i][j];  
  9.             }  
  10.         }  
  11.         // 对行变换  
  12.         for (int i = 0; i <= 7; i++) {  
  13.             double S07, S16, S25, S34, S0734, S1625;  
  14.             double D07, D16, D25, D34, D0734, D1625;  
  15.             S07 = blk[i][0] + blk[i][7];  
  16.             S16 = blk[i][1] + blk[i][6];  
  17.             S25 = blk[i][2] + blk[i][5];  
  18.             S34 = blk[i][3] + blk[i][4];  
  19.             S0734 = S07 + S34;  
  20.             S1625 = S16 + S25;  
  21.             D07 = blk[i][0] - blk[i][7];  
  22.             D16 = blk[i][1] - blk[i][6];  
  23.             D25 = blk[i][2] - blk[i][5];  
  24.             D34 = blk[i][3] - blk[i][4];  
  25.             D0734 = S07 - S34;  
  26.             D1625 = S16 - S25;  
  27.             blk[i][0] = 0.5 * (C4 * (S0734 + S1625));  
  28.             blk[i][1] = 0.5 * (C1 * D07 + C3 * D16 + C5 * D25 + C7 * D34);  
  29.             blk[i][2] = 0.5 * (C2 * D0734 + C6 * D1625);  
  30.             blk[i][3] = 0.5 * (C3 * D07 - C7 * D16 - C1 * D25 - C5 * D34);  
  31.             blk[i][4] = 0.5 * (C4 * (S0734 - S1625));  
  32.             blk[i][5] = 0.5 * (C5 * D07 - C1 * D16 + C7 * D25 + C3 * D34);  
  33.             blk[i][6] = 0.5 * (C6 * D0734 - C2 * D1625);  
  34.             blk[i][7] = 0.5 * (C7 * D07 - C5 * D16 + C3 * D25 - C1 * D34);  
  35.         }  
  36.         // 对列变换  
  37.         for (int j = 0; j <= 7; j++) {  
  38.             double S07, S16, S25, S34, S0734, S1625;  
  39.             double D07, D16, D25, D34, D0734, D1625;  
  40.             S07 = blk[0][j] + blk[7][j];  
  41.             S16 = blk[1][j] + blk[6][j];  
  42.             S25 = blk[2][j] + blk[5][j];  
  43.             S34 = blk[3][j] + blk[4][j];  
  44.             S0734 = S07 + S34;  
  45.             S1625 = S16 + S25;  
  46.             D07 = blk[0][j] - blk[7][j];  
  47.             D16 = blk[1][j] - blk[6][j];  
  48.             D25 = blk[2][j] - blk[5][j];  
  49.             D34 = blk[3][j] - blk[4][j];  
  50.             D0734 = S07 - S34;  
  51.             D1625 = S16 - S25;  
  52.             blk[0][j] = 0.5 * (C4 * (S0734 + S1625));  
  53.             blk[1][j] = 0.5 * (C1 * D07 + C3 * D16 + C5 * D25 + C7 * D34);  
  54.             blk[2][j] = 0.5 * (C2 * D0734 + C6 * D1625);  
  55.             blk[3][j] = 0.5 * (C3 * D07 - C7 * D16 - C1 * D25 - C5 * D34);  
  56.             blk[4][j] = 0.5 * (C4 * (S0734 - S1625));  
  57.             blk[5][j] = 0.5 * (C5 * D07 - C1 * D16 + C7 * D25 + C3 * D34);  
  58.             blk[6][j] = 0.5 * (C6 * D0734 - C2 * D1625);  
  59.             blk[7][j] = 0.5 * (C7 * D07 - C5 * D16 + C3 * D25 - C1 * D34);  
  60.         }  
  61.         return blk;  
  62.     }  
  63. }  

[java]  view plain copy
  1. package com.zeph.watermark.fdct;  
  2.   
  3. public class IFDct implements Dct {  
  4.     public static double[][] iFDctTransform(double[][] ablk) {  
  5.         double[][] blk = new double[8][8];  
  6.         for (int i = 0; i < 8; i++) {  
  7.             for (int j = 0; j < 8; j++) {  
  8.                 blk[i][j] = ablk[i][j];  
  9.             }  
  10.         }  
  11.         // 对列做IDCT  
  12.         for (int j = 0; j <= 7; j++) {  
  13.             double[] tmp = new double[16];  
  14.             // first step  
  15.             tmp[0] = blk[0][j] * C4 + blk[2][j] * C2;  
  16.             tmp[1] = blk[4][j] * C4 + blk[6][j] * C6;  
  17.             tmp[2] = blk[0][j] * C4 + blk[2][j] * C6;  
  18.             tmp[3] = -blk[4][j] * C4 - blk[6][j] * C2;  
  19.             tmp[4] = blk[0][j] * C4 - blk[2][j] * C6;  
  20.             tmp[5] = -blk[4][j] * C4 + blk[6][j] * C2;  
  21.             tmp[6] = blk[0][j] * C4 - blk[2][j] * C2;  
  22.             tmp[7] = blk[4][j] * C4 - blk[6][j] * C6;  
  23.             tmp[8] = blk[1][j] * C7 - blk[3][j] * C5;  
  24.             tmp[9] = blk[5][j] * C3 - blk[7][j] * C1;  
  25.             tmp[10] = blk[1][j] * C5 - blk[3][j] * C1;  
  26.             tmp[11] = blk[5][j] * C7 + blk[7][j] * C3;  
  27.             tmp[12] = blk[1][j] * C3 - blk[3][j] * C7;  
  28.             tmp[13] = -blk[5][j] * C1 - blk[7][j] * C5;  
  29.             tmp[14] = blk[1][j] * C1 + blk[3][j] * C3;  
  30.             tmp[15] = blk[5][j] * C5 + blk[7][j] * C7;  
  31.             // second step  
  32.             tmp[0] = 0.5 * (tmp[0] + tmp[1]);  
  33.             tmp[1] = 0.5 * (tmp[2] + tmp[3]);  
  34.             tmp[2] = 0.5 * (tmp[4] + tmp[5]);  
  35.             tmp[3] = 0.5 * (tmp[6] + tmp[7]);  
  36.             tmp[4] = 0.5 * (tmp[8] + tmp[9]);  
  37.             tmp[5] = 0.5 * (tmp[10] + tmp[11]);  
  38.             tmp[6] = 0.5 * (tmp[12] + tmp[13]);  
  39.             tmp[7] = 0.5 * (tmp[14] + tmp[15]);  
  40.             // third step  
  41.             blk[0][j] = tmp[0] + tmp[7];  
  42.             blk[1][j] = tmp[1] + tmp[6];  
  43.             blk[2][j] = tmp[2] + tmp[5];  
  44.             blk[3][j] = tmp[3] + tmp[4];  
  45.             blk[4][j] = tmp[3] - tmp[4];  
  46.             blk[5][j] = tmp[2] - tmp[5];  
  47.             blk[6][j] = tmp[1] - tmp[6];  
  48.             blk[7][j] = tmp[0] - tmp[7];  
  49.         }  
  50.         // 对行做IDCT  
  51.         for (int i = 0; i <= 7; i++) {  
  52.             double[] tmp = new double[16];  
  53.             // first step  
  54.             tmp[0] = blk[i][0] * C4 + blk[i][2] * C2;  
  55.             tmp[1] = blk[i][4] * C4 + blk[i][6] * C6;  
  56.             tmp[2] = blk[i][0] * C4 + blk[i][2] * C6;  
  57.             tmp[3] = -blk[i][4] * C4 - blk[i][6] * C2;  
  58.             tmp[4] = blk[i][0] * C4 - blk[i][2] * C6;  
  59.             tmp[5] = -blk[i][4] * C4 + blk[i][6] * C2;  
  60.             tmp[6] = blk[i][0] * C4 - blk[i][2] * C2;  
  61.             tmp[7] = blk[i][4] * C4 - blk[i][6] * C6;  
  62.             tmp[8] = blk[i][1] * C7 - blk[i][3] * C5;  
  63.             tmp[9] = blk[i][5] * C3 - blk[i][7] * C1;  
  64.             tmp[10] = blk[i][1] * C5 - blk[i][3] * C1;  
  65.             tmp[11] = blk[i][5] * C7 + blk[i][7] * C3;  
  66.             tmp[12] = blk[i][1] * C3 - blk[i][3] * C7;  
  67.             tmp[13] = -blk[i][5] * C1 - blk[i][7] * C5;  
  68.             tmp[14] = blk[i][1] * C1 + blk[i][3] * C3;  
  69.             tmp[15] = blk[i][5] * C5 + blk[i][7] * C7;  
  70.             // second step  
  71.             tmp[0] = 0.5 * (tmp[0] + tmp[1]);  
  72.             tmp[1] = 0.5 * (tmp[2] + tmp[3]);  
  73.             tmp[2] = 0.5 * (tmp[4] + tmp[5]);  
  74.             tmp[3] = 0.5 * (tmp[6] + tmp[7]);  
  75.             tmp[4] = 0.5 * (tmp[8] + tmp[9]);  
  76.             tmp[5] = 0.5 * (tmp[10] + tmp[11]);  
  77.             tmp[6] = 0.5 * (tmp[12] + tmp[13]);  
  78.             tmp[7] = 0.5 * (tmp[14] + tmp[15]);  
  79.             // third step  
  80.             blk[i][0] = tmp[0] + tmp[7];  
  81.             blk[i][1] = tmp[1] + tmp[6];  
  82.             blk[i][2] = tmp[2] + tmp[5];  
  83.             blk[i][3] = tmp[3] + tmp[4];  
  84.             blk[i][4] = tmp[3] - tmp[4];  
  85.             blk[i][5] = tmp[2] - tmp[5];  
  86.             blk[i][6] = tmp[1] - tmp[6];  
  87.             blk[i][7] = tmp[0] - tmp[7];  
  88.         }  
  89.         return blk;  
  90.     }  
  91.   
  92. }  
[java]  view plain copy
  1. package com.zeph.watermark.fdct;  
  2.   
  3. public class IFDct implements Dct {  
  4.     public static double[][] iFDctTransform(double[][] ablk) {  
  5.         double[][] blk = new double[8][8];  
  6.         for (int i = 0; i < 8; i++) {  
  7.             for (int j = 0; j < 8; j++) {  
  8.                 blk[i][j] = ablk[i][j];  
  9.             }  
  10.         }  
  11.         // 对列做IDCT  
  12.         for (int j = 0; j <= 7; j++) {  
  13.             double[] tmp = new double[16];  
  14.             // first step  
  15.             tmp[0] = blk[0][j] * C4 + blk[2][j] * C2;  
  16.             tmp[1] = blk[4][j] * C4 + blk[6][j] * C6;  
  17.             tmp[2] = blk[0][j] * C4 + blk[2][j] * C6;  
  18.             tmp[3] = -blk[4][j] * C4 - blk[6][j] * C2;  
  19.             tmp[4] = blk[0][j] * C4 - blk[2][j] * C6;  
  20.             tmp[5] = -blk[4][j] * C4 + blk[6][j] * C2;  
  21.             tmp[6] = blk[0][j] * C4 - blk[2][j] * C2;  
  22.             tmp[7] = blk[4][j] * C4 - blk[6][j] * C6;  
  23.             tmp[8] = blk[1][j] * C7 - blk[3][j] * C5;  
  24.             tmp[9] = blk[5][j] * C3 - blk[7][j] * C1;  
  25.             tmp[10] = blk[1][j] * C5 - blk[3][j] * C1;  
  26.             tmp[11] = blk[5][j] * C7 + blk[7][j] * C3;  
  27.             tmp[12] = blk[1][j] * C3 - blk[3][j] * C7;  
  28.             tmp[13] = -blk[5][j] * C1 - blk[7][j] * C5;  
  29.             tmp[14] = blk[1][j] * C1 + blk[3][j] * C3;  
  30.             tmp[15] = blk[5][j] * C5 + blk[7][j] * C7;  
  31.             // second step  
  32.             tmp[0] = 0.5 * (tmp[0] + tmp[1]);  
  33.             tmp[1] = 0.5 * (tmp[2] + tmp[3]);  
  34.             tmp[2] = 0.5 * (tmp[4] + tmp[5]);  
  35.             tmp[3] = 0.5 * (tmp[6] + tmp[7]);  
  36.             tmp[4] = 0.5 * (tmp[8] + tmp[9]);  
  37.             tmp[5] = 0.5 * (tmp[10] + tmp[11]);  
  38.             tmp[6] = 0.5 * (tmp[12] + tmp[13]);  
  39.             tmp[7] = 0.5 * (tmp[14] + tmp[15]);  
  40.             // third step  
  41.             blk[0][j] = tmp[0] + tmp[7];  
  42.             blk[1][j] = tmp[1] + tmp[6];  
  43.             blk[2][j] = tmp[2] + tmp[5];  
  44.             blk[3][j] = tmp[3] + tmp[4];  
  45.             blk[4][j] = tmp[3] - tmp[4];  
  46.             blk[5][j] = tmp[2] - tmp[5];  
  47.             blk[6][j] = tmp[1] - tmp[6];  
  48.             blk[7][j] = tmp[0] - tmp[7];  
  49.         }  
  50.         // 对行做IDCT  
  51.         for (int i = 0; i <= 7; i++) {  
  52.             double[] tmp = new double[16];  
  53.             // first step  
  54.             tmp[0] = blk[i][0] * C4 + blk[i][2] * C2;  
  55.             tmp[1] = blk[i][4] * C4 + blk[i][6] * C6;  
  56.             tmp[2] = blk[i][0] * C4 + blk[i][2] * C6;  
  57.             tmp[3] = -blk[i][4] * C4 - blk[i][6] * C2;  
  58.             tmp[4] = blk[i][0] * C4 - blk[i][2] * C6;  
  59.             tmp[5] = -blk[i][4] * C4 + blk[i][6] * C2;  
  60.             tmp[6] = blk[i][0] * C4 - blk[i][2] * C2;  
  61.             tmp[7] = blk[i][4] * C4 - blk[i][6] * C6;  
  62.             tmp[8] = blk[i][1] * C7 - blk[i][3] * C5;  
  63.             tmp[9] = blk[i][5] * C3 - blk[i][7] * C1;  
  64.             tmp[10] = blk[i][1] * C5 - blk[i][3] * C1;  
  65.             tmp[11] = blk[i][5] * C7 + blk[i][7] * C3;  
  66.             tmp[12] = blk[i][1] * C3 - blk[i][3] * C7;  
  67.             tmp[13] = -blk[i][5] * C1 - blk[i][7] * C5;  
  68.             tmp[14] = blk[i][1] * C1 + blk[i][3] * C3;  
  69.             tmp[15] = blk[i][5] * C5 + blk[i][7] * C7;  
  70.             // second step  
  71.             tmp[0] = 0.5 * (tmp[0] + tmp[1]);  
  72.             tmp[1] = 0.5 * (tmp[2] + tmp[3]);  
  73.             tmp[2] = 0.5 * (tmp[4] + tmp[5]);  
  74.             tmp[3] = 0.5 * (tmp[6] + tmp[7]);  
  75.             tmp[4] = 0.5 * (tmp[8] + tmp[9]);  
  76.             tmp[5] = 0.5 * (tmp[10] + tmp[11]);  
  77.             tmp[6] = 0.5 * (tmp[12] + tmp[13]);  
  78.             tmp[7] = 0.5 * (tmp[14] + tmp[15]);  
  79.             // third step  
  80.             blk[i][0] = tmp[0] + tmp[7];  
  81.             blk[i][1] = tmp[1] + tmp[6];  
  82.             blk[i][2] = tmp[2] + tmp[5];  
  83.             blk[i][3] = tmp[3] + tmp[4];  
  84.             blk[i][4] = tmp[3] - tmp[4];  
  85.             blk[i][5] = tmp[2] - tmp[5];  
  86.             blk[i][6] = tmp[1] - tmp[6];  
  87.             blk[i][7] = tmp[0] - tmp[7];  
  88.         }  
  89.         return blk;  
  90.     }  
  91.   
  92. }  

[java]  view plain copy
  1. package com.zeph.watermark.fdct;  
  2.   
  3. import java.awt.image.BufferedImage;  
  4. import java.awt.image.WritableRaster;  
  5.   
  6. import com.zeph.watermark.util.ImageUtil;  
  7. import com.zeph.watermark.util.MathTool;  
  8.   
  9.   
  10. public class AddWatermark {  
  11.     private static final int d = 5;  
  12.   
  13.     public static void main(String[] args) {  
  14.         AddWatermark embed = new AddWatermark();  
  15.         embed.start();  
  16.     }  
  17.   
  18.     public void start() {  
  19.         BufferedImage oImage = ImageUtil.getImage("D://lena.jpg");  
  20.         BufferedImage wImage = ImageUtil.getImage("D://zhong.bmp");  
  21.         int type = oImage.getType();  
  22.         WritableRaster oRaster = oImage.getRaster();  
  23.         WritableRaster wRaster = wImage.getRaster();  
  24.         int oWidth = oRaster.getWidth();  
  25.         int oHeight = oRaster.getHeight();  
  26.         int wWidth = wRaster.getWidth();  
  27.         int wHeight = wRaster.getHeight();  
  28.         int[] oPixels = new int[3 * oWidth * oHeight];  
  29.         int[] wPixels = new int[wWidth * wHeight];  
  30.         oRaster.getPixels(0, 0, oWidth, oHeight, oPixels);  
  31.         wRaster.getPixels(0, 0, wWidth, wHeight, wPixels);  
  32.         int[][][] RGBPixels = ImageUtil.getRGBArrayToMatrix(oPixels, oWidth,  
  33.                 oHeight);  
  34.         // 得到RGB图像的三层矩阵表示  
  35.         double[][] rPixels = MathTool.intToDoubleMatrix(RGBPixels[2]);  
  36.         int[][] wDMatrix = ImageUtil.arrayToMatrix(wPixels, wWidth, wHeight);  
  37.         double[][] result = rPixels;  
  38.         // 嵌入算法  
  39.         for (int i = 0; i < wWidth; i++) {  
  40.             for (int j = 0; j < wHeight; j++) {  
  41.                 double[][] blk = new double[8][8];  
  42.                 // 对原始图像8 * 8 分块  
  43.                 for (int m = 0; m < 8; m++) {  
  44.                     for (int n = 0; n < 8; n++) {  
  45.                         blk[m][n] = rPixels[8 * i + m][8 * j + n];  
  46.                     }  
  47.                 }  
  48.                 double[][] dBlk = FDct.fDctTransform(blk);  
  49.                 if (wDMatrix[i][j] == 0) {  
  50.                     dBlk[3][3] = dBlk[3][3] - d;  
  51.                     dBlk[3][4] = dBlk[3][4] - d;  
  52.                     dBlk[3][5] = dBlk[3][5] - d;  
  53.                     dBlk[4][3] = dBlk[4][3] - d;  
  54.                     dBlk[5][3] = dBlk[5][3] - d;  
  55.                 } else {  
  56.                     dBlk[3][3] = dBlk[3][3] + d;  
  57.                     dBlk[3][4] = dBlk[3][4] + d;  
  58.                     dBlk[3][5] = dBlk[3][5] + d;  
  59.                     dBlk[4][3] = dBlk[4][3] + d;  
  60.                     dBlk[5][3] = dBlk[5][3] + d;  
  61.                 }  
  62.                 blk = IFDct.iFDctTransform(dBlk);  
  63.                 for (int m = 0; m < 8; m++) {  
  64.                     for (int n = 0; n < 8; n++) {  
  65.                         result[8 * i + m][8 * j + n] = blk[m][n];  
  66.                     }  
  67.                 }  
  68.             }  
  69.         }  
  70.         double[][][] temp = new double[3][oWidth][oHeight];  
  71.         temp[0] = MathTool.intToDoubleMatrix(RGBPixels[0]);  
  72.         temp[1] = MathTool.intToDoubleMatrix(RGBPixels[1]);  
  73.         temp[2] = result;  
  74.         double[] rgbResult = ImageUtil.getRGBMatrixToArray(temp);  
  75.         // 将BufferedImage对象写入磁盘  
  76.         ImageUtil.setImage(rgbResult, oWidth, oHeight, "D://result.bmp",  
  77.                 "bmp", type);  
  78.     }  
  79.   
  80. }  
[java]  view plain copy
  1. package com.zeph.watermark.fdct;  
  2.   
  3. import java.awt.image.BufferedImage;  
  4. import java.awt.image.WritableRaster;  
  5.   
  6. import com.zeph.watermark.util.ImageUtil;  
  7. import com.zeph.watermark.util.MathTool;  
  8.   
  9.   
  10. public class AddWatermark {  
  11.     private static final int d = 5;  
  12.   
  13.     public static void main(String[] args) {  
  14.         AddWatermark embed = new AddWatermark();  
  15.         embed.start();  
  16.     }  
  17.   
  18.     public void start() {  
  19.         BufferedImage oImage = ImageUtil.getImage("D://lena.jpg");  
  20.         BufferedImage wImage = ImageUtil.getImage("D://zhong.bmp");  
  21.         int type = oImage.getType();  
  22.         WritableRaster oRaster = oImage.getRaster();  
  23.         WritableRaster wRaster = wImage.getRaster();  
  24.         int oWidth = oRaster.getWidth();  
  25.         int oHeight = oRaster.getHeight();  
  26.         int wWidth = wRaster.getWidth();  
  27.         int wHeight = wRaster.getHeight();  
  28.         int[] oPixels = new int[3 * oWidth * oHeight];  
  29.         int[] wPixels = new int[wWidth * wHeight];  
  30.         oRaster.getPixels(0, 0, oWidth, oHeight, oPixels);  
  31.         wRaster.getPixels(0, 0, wWidth, wHeight, wPixels);  
  32.         int[][][] RGBPixels = ImageUtil.getRGBArrayToMatrix(oPixels, oWidth,  
  33.                 oHeight);  
  34.         // 得到RGB图像的三层矩阵表示  
  35.         double[][] rPixels = MathTool.intToDoubleMatrix(RGBPixels[2]);  
  36.         int[][] wDMatrix = ImageUtil.arrayToMatrix(wPixels, wWidth, wHeight);  
  37.         double[][] result = rPixels;  
  38.         // 嵌入算法  
  39.         for (int i = 0; i < wWidth; i++) {  
  40.             for (int j = 0; j < wHeight; j++) {  
  41.                 double[][] blk = new double[8][8];  
  42.                 // 对原始图像8 * 8 分块  
  43.                 for (int m = 0; m < 8; m++) {  
  44.                     for (int n = 0; n < 8; n++) {  
  45.                         blk[m][n] = rPixels[8 * i + m][8 * j + n];  
  46.                     }  
  47.                 }  
  48.                 double[][] dBlk = FDct.fDctTransform(blk);  
  49.                 if (wDMatrix[i][j] == 0) {  
  50.                     dBlk[3][3] = dBlk[3][3] - d;  
  51.                     dBlk[3][4] = dBlk[3][4] - d;  
  52.                     dBlk[3][5] = dBlk[3][5] - d;  
  53.                     dBlk[4][3] = dBlk[4][3] - d;  
  54.                     dBlk[5][3] = dBlk[5][3] - d;  
  55.                 } else {  
  56.                     dBlk[3][3] = dBlk[3][3] + d;  
  57.                     dBlk[3][4] = dBlk[3][4] + d;  
  58.                     dBlk[3][5] = dBlk[3][5] + d;  
  59.                     dBlk[4][3] = dBlk[4][3] + d;  
  60.                     dBlk[5][3] = dBlk[5][3] + d;  
  61.                 }  
  62.                 blk = IFDct.iFDctTransform(dBlk);  
  63.                 for (int m = 0; m < 8; m++) {  
  64.                     for (int n = 0; n < 8; n++) {  
  65.                         result[8 * i + m][8 * j + n] = blk[m][n];  
  66.                     }  
  67.                 }  
  68.             }  
  69.         }  
  70.         double[][][] temp = new double[3][oWidth][oHeight];  
  71.         temp[0] = MathTool.intToDoubleMatrix(RGBPixels[0]);  
  72.         temp[1] = MathTool.intToDoubleMatrix(RGBPixels[1]);  
  73.         temp[2] = result;  
  74.         double[] rgbResult = ImageUtil.getRGBMatrixToArray(temp);  
  75.         // 将BufferedImage对象写入磁盘  
  76.         ImageUtil.setImage(rgbResult, oWidth, oHeight, "D://result.bmp",  
  77.                 "bmp", type);  
  78.     }  
  79.   
  80. }  

[java]  view plain copy
  1. package com.zeph.watermark.fdct;  
  2.   
  3. import java.awt.image.BufferedImage;  
  4. import java.awt.image.WritableRaster;  
  5.   
  6. import com.zeph.watermark.util.ImageUtil;  
  7. import com.zeph.watermark.util.MathTool;  
  8.   
  9.   
  10. public class ExtractWatermark {  
  11.     public static void main(String[] args) {  
  12.         ExtractWatermark distill = new ExtractWatermark();  
  13.         distill.start(32, 32);  
  14.     }  
  15.   
  16.     public void start(int wWidth, int wHeight) {  
  17.         // mImage是嵌入水印后的图像  
  18.         BufferedImage mImage = ImageUtil.getImage("D://result.bmp");  
  19.         // 原始图像  
  20.         BufferedImage oImage = ImageUtil.getImage("D://lena.jpg");  
  21.         WritableRaster oRaster = oImage.getRaster();  
  22.         WritableRaster mRaster = mImage.getRaster();  
  23.         int oWidth = oRaster.getWidth();  
  24.         int oHeight = oRaster.getHeight();  
  25.         int[] oPixels = new int[3 * oWidth * oHeight];  
  26.         int[] mPixels = new int[3 * oWidth * oHeight];  
  27.         oRaster.getPixels(0, 0, oWidth, oHeight, oPixels);  
  28.         mRaster.getPixels(0, 0, oWidth, oHeight, mPixels);  
  29.         // 得rgb图像三层矩阵，mRgbPixels[0]表示b层分量  
  30.         int[][][] mRgbPixels = ImageUtil.getRGBArrayToMatrix(mPixels, oWidth,  
  31.                 oHeight);  
  32.         int[][][] oRgbPixels = ImageUtil.getRGBArrayToMatrix(oPixels, oWidth,  
  33.                 oHeight);  
  34.         double[][] oDPixels = MathTool.intToDoubleMatrix(mRgbPixels[2]);  
  35.         double[][] mDPixels = MathTool.intToDoubleMatrix(oRgbPixels[2]);  
  36.         double[][] result = new double[wWidth][wHeight];  
  37.         for (int i = 0; i < wWidth; i++) {  
  38.             for (int j = 0; j < wHeight; j++) {  
  39.                 double[][] oBlk = new double[8][8];  
  40.                 double[][] mBlk = new double[8][8];  
  41.                 int d = 0;  
  42.                 int f = 0;  
  43.                 for (int m = 0; m < 8; m++) {  
  44.                     for (int n = 0; n < 8; n++) {  
  45.                         oBlk[m][n] = oDPixels[8 * i + m][8 * j + n];  
  46.                         mBlk[m][n] = mDPixels[8 * i + m][8 * j + n];  
  47.                     }  
  48.                 }  
  49.                 double[][] dOBlk = FDct.fDctTransform(oBlk);  
  50.                 double[][] dMBlk = FDct.fDctTransform(mBlk);  
  51.                 if (dOBlk[3][3] > dMBlk[3][3]) {  
  52.                     d++;  
  53.                 } else {  
  54.                     f++;  
  55.                 }  
  56.                 if (dOBlk[3][4] > dMBlk[3][4]) {  
  57.                     d++;  
  58.                 } else {  
  59.                     f++;  
  60.                 }  
  61.                 if (dOBlk[3][5] > dMBlk[3][5]) {  
  62.                     d++;  
  63.                 } else {  
  64.                     f++;  
  65.                 }  
  66.                 if (dOBlk[4][3] > dMBlk[4][3]) {  
  67.                     d++;  
  68.                 } else {  
  69.                     f++;  
  70.                 }  
  71.                 if (dOBlk[5][3] > dMBlk[5][3]) {  
  72.                     d++;  
  73.                 } else {  
  74.                     f++;  
  75.                 }  
  76.                 if (d < f) {  
  77.                     result[i][j] = 0;  
  78.                 } else {  
  79.                     result[i][j] = 1;  
  80.                 }  
  81.             }  
  82.         }  
  83.         double[] outResult = ImageUtil.matrixToArray(result);  
  84.         // 把嵌入水印的结果写到BufferedImage对象  
  85.         ImageUtil.setImage(outResult, wWidth, wHeight, "D://mark.bmp", "bmp",  
  86.                 BufferedImage.TYPE_BYTE_BINARY);  
  87.     }  
  88.   
  89. }  
[java]  view plain copy
  1. package com.zeph.watermark.fdct;  
  2.   
  3. import java.awt.image.BufferedImage;  
  4. import java.awt.image.WritableRaster;  
  5.   
  6. import com.zeph.watermark.util.ImageUtil;  
  7. import com.zeph.watermark.util.MathTool;  
  8.   
  9.   
  10. public class ExtractWatermark {  
  11.     public static void main(String[] args) {  
  12.         ExtractWatermark distill = new ExtractWatermark();  
  13.         distill.start(32, 32);  
  14.     }  
  15.   
  16.     public void start(int wWidth, int wHeight) {  
  17.         // mImage是嵌入水印后的图像  
  18.         BufferedImage mImage = ImageUtil.getImage("D://result.bmp");  
  19.         // 原始图像  
  20.         BufferedImage oImage = ImageUtil.getImage("D://lena.jpg");  
  21.         WritableRaster oRaster = oImage.getRaster();  
  22.         WritableRaster mRaster = mImage.getRaster();  
  23.         int oWidth = oRaster.getWidth();  
  24.         int oHeight = oRaster.getHeight();  
  25.         int[] oPixels = new int[3 * oWidth * oHeight];  
  26.         int[] mPixels = new int[3 * oWidth * oHeight];  
  27.         oRaster.getPixels(0, 0, oWidth, oHeight, oPixels);  
  28.         mRaster.getPixels(0, 0, oWidth, oHeight, mPixels);  
  29.         // 得rgb图像三层矩阵，mRgbPixels[0]表示b层分量  
  30.         int[][][] mRgbPixels = ImageUtil.getRGBArrayToMatrix(mPixels, oWidth,  
  31.                 oHeight);  
  32.         int[][][] oRgbPixels = ImageUtil.getRGBArrayToMatrix(oPixels, oWidth,  
  33.                 oHeight);  
  34.         double[][] oDPixels = MathTool.intToDoubleMatrix(mRgbPixels[2]);  
  35.         double[][] mDPixels = MathTool.intToDoubleMatrix(oRgbPixels[2]);  
  36.         double[][] result = new double[wWidth][wHeight];  
  37.         for (int i = 0; i < wWidth; i++) {  
  38.             for (int j = 0; j < wHeight; j++) {  
  39.                 double[][] oBlk = new double[8][8];  
  40.                 double[][] mBlk = new double[8][8];  
  41.                 int d = 0;  
  42.                 int f = 0;  
  43.                 for (int m = 0; m < 8; m++) {  
  44.                     for (int n = 0; n < 8; n++) {  
  45.                         oBlk[m][n] = oDPixels[8 * i + m][8 * j + n];  
  46.                         mBlk[m][n] = mDPixels[8 * i + m][8 * j + n];  
  47.                     }  
  48.                 }  
  49.                 double[][] dOBlk = FDct.fDctTransform(oBlk);  
  50.                 double[][] dMBlk = FDct.fDctTransform(mBlk);  
  51.                 if (dOBlk[3][3] > dMBlk[3][3]) {  
  52.                     d++;  
  53.                 } else {  
  54.                     f++;  
  55.                 }  
  56.                 if (dOBlk[3][4] > dMBlk[3][4]) {  
  57.                     d++;  
  58.                 } else {  
  59.                     f++;  
  60.                 }  
  61.                 if (dOBlk[3][5] > dMBlk[3][5]) {  
  62.                     d++;  
  63.                 } else {  
  64.                     f++;  
  65.                 }  
  66.                 if (dOBlk[4][3] > dMBlk[4][3]) {  
  67.                     d++;  
  68.                 } else {  
  69.                     f++;  
  70.                 }  
  71.                 if (dOBlk[5][3] > dMBlk[5][3]) {  
  72.                     d++;  
  73.                 } else {  
  74.                     f++;  
  75.                 }  
  76.                 if (d < f) {  
  77.                     result[i][j] = 0;  
  78.                 } else {  
  79.                     result[i][j] = 1;  
  80.                 }  
  81.             }  
  82.         }  
  83.         double[] outResult = ImageUtil.matrixToArray(result);  
  84.         // 把嵌入水印的结果写到BufferedImage对象  
  85.         ImageUtil.setImage(outResult, wWidth, wHeight, "D://mark.bmp", "bmp",  
  86.                 BufferedImage.TYPE_BYTE_BINARY);  
  87.     }  
  88.   
  89. }  
wang1270944973
关注
专栏目录
java实现离散余弦变换 (附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-18 215
java实现离散余弦变换 (附完整源码)
java实现图像水印(基于快速离散余弦变换FDCT)
04-21
java实现图像水印(基于快速离散余弦变换FDCT)
Java实现【快速离散余弦变换FDCT】参考：《图像数字水印的JAVA实现 刘剑鸣 著》
热门推荐
学海无涯 苦写博客
02-20 1万+
原始图片： 水印图片： 嵌入水印后的图片： 提取出来的水印图片： 工具类：ImageUtil.java    MathTool.java package com.zeph.watermark.util; public class MathTool { public static double[][] intToDoubleMatrix(int[][
在Java源码中添加隐形签名和数字水印的实现方法
最新发布
weixin_41894177的博客
06-17 403
在软件开发和分发的过程中，代码的版权保护和溯源成为一个重要的需求。无论是为了防止代码被盗用，还是为了跟踪代码的修改历史，确保代码的合法来源都是至关重要的。这就引出了如何在源码文件中添加签名和水印，以实现代码的溯源和验证。传统的数字签名方法可以生成文件的唯一签名，但这些方法往往在文件的外部生成和验证，容易被忽略或篡改。而在源码文件中嵌入不可删除的隐形签名或数字水印，则可以在不影响代码运行的情况下，确保签名的难以被发现或删除。本文将探讨如何在Java源码文件中添加隐形签名和数字水印，以实现对源码的有效保护。
Java使用OpenCV：基于DCT变换 实现 图片 数字 的盲水印添加和提取
稀饭
08-09 7085
此水印算法的相关说明： 嵌入图片： 水印图：只能是64 * 64的二值图 原图：只能是512 * 512的图片 嵌入数字： 数字：只能是0或者1的数字嵌入到图片中，可以嵌入64 * 64=4096个0或者1 原图：只能是512 * 512的图片 改算法目前只能抵抗： 亮度，压缩，对比度，饱和度，缩放这些攻击。 对于缩放而言需要注意的是，任何缩放，不管它缩放的比例是多少，我们在最后提取水印的时候必须...
基于改进DTC的数字水印Java实现（应用于移动端Android）------阿冬专栏
阿冬专栏
10-17 2167
具体的实现代码见博客所传资源，将此资源应用于Android应用APP时，别忘了引入jdk，因为这个java源代码是基于jdk写的，引入Android应用之后，便可进行相关移动端的使用。
Java实现添加文字水印、图片水印功能实战
yuechuzhixing的博客
10-09 1618
java实现给图片添加水印实现步骤：获取原图片对象信息（本地图片或网络图片）添加水印（设置水印颜色、字体、坐标等）处理输出目标图片。
基于DCT信息隐藏 数字水印 DCT matlab实现
qq_44465615的博客
04-06 2417
1、DCT变化 2、DCT中频： 中频指DCT变化后从左上到右下的线经过点 3、代码实现 %------------------------------------------------------------------% % 基于DCT变换的信息隐藏(数字水印) %% %%
water水印（DCT变换过程）
missingu1314的专栏
03-15 8814
DCT变换： 低频和高频来源是声音的频率，这里根据纹理形象化了; 高频/低频是指图像从纹理角度看，纹理细密/细小/稠密的为高频信息，例如均匀一致的路面，水面等，低频就是指那些较粗的纹理，如边缘信息等，图象上明 亮变化快而显著的信息就是“高频”信息； 图象上明亮变化慢而相似的信息就是“低频”信息。 对于图像来说。 空域的高频可以理解为细节信号，比如当一幅大图缩小n倍后，图像的
FDCT_快速离散余弦变换_
10-02
快速离散余弦变换（Fast Discrete Cosine Transform, FDCT）是数字信号处理和图像压缩领域中的一个重要算法。它是离散余弦变换（DCT）的一种优化实现，旨在提高计算效率，降低计算复杂度。在诸如JPEG图像压缩标准中...
DCT.rar_余弦变换_离散余弦变换
09-23
离散余弦变换（Discrete Cosine Transform, DCT）是一种在数字信号处理和图像压缩领域广泛应用的数学变换方法。它是连续余弦变换的离散形式，尤其在图像编码标准如JPEG和视频编码标准如MPEG中发挥着关键作用。本压缩...
JAVA实现对图片的快速离散傅里叶变换和离散余弦变换
05-02
图片的处理，使用蝶式算法实现快速离散傅里叶变换，使用NetBeans编写。
一个用JAVA编写的DCT变换的类
07-30
这是一个用JAVA编写的DCT变换的类 给那些有需要的同学们
如何使用JAVA实现数字水印
09-03
本文介绍了如何使用JAVA实现数字水印，主要用到了java.awt包中的AlphaComposite类,需要学习制作水印的朋友可以参考下
使用java实现图片水印
12-23
是一 使 用 java 来 实现图片水印的效果
基于改进dct数字水印的java实现
10-17
基于改进dct的数字水印Java实现代码
离散余弦变换代码
09-27
离散余弦变换（Discrete Cosine Transform, DCT）是一种在数字信号处理领域广泛应用的数学变换技术。它能够将信号或图像数据从时域或空域转换到频域，从而便于进行数据压缩、噪声过滤等操作。DCT在图像编码、音频...
DCT(离散余弦变换)C#源代码
11-11
**离散余弦变换（Discrete Cosine Transform, DCT）**是一种广泛应用于数字信号处理领域的数学工具，尤其在图像压缩、音频编码等多媒体技术中扮演着重要角色。DCT的主要作用是将时域或空间域的数据转换到频域表示，...
Java实现添加文字水印、图片水印
Javaの甘乃迪的博客
10-24 6702
Java实现添加文字水印、图片水印
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值