Learning/shuiyin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

添加C#实现

Browse Source
This commit is contained in:
ShaoHua
2025-12-27 20:36:56 +08:00
parent a5303d6f3e
commit ce394c0646
21 changed files with 1312 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ShuiYinCSharp/Com/Lmc/ShuiYin/ImageWatermarkUtilMain.cs
+35
View File
@@ -0,0 +1,35 @@
using System;
using System.IO;
using Com.Lmc.ShuiYin.One.Util;
using OpenCvSharp;
namespace Com.Lmc.ShuiYin
{
public class ImageWatermarkUtilMain
{
public static void Run(string[] args)
{
string baseDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestImages");
string src = Path.Combine(baseDir, "meinv.png");
Mat img = Utils.Read(src, 1); // CV_8S -> Color (1)
Mat outImg = ImgWatermarkUtil.AddImageWatermarkWithText(img, "cheshen");
string watermarked = Path.Combine(baseDir, "meinv2.png");
Cv2.ImWrite(watermarked, outImg);
Mat watermarkImg = ImgWatermarkUtil.GetImageWatermarkWithText(outImg);
string extracted = Path.Combine(baseDir, "meinv3.png");
Cv2.ImWrite(extracted, watermarkImg);
string src2 = Path.Combine(baseDir, "444.png");
Mat img444 = Utils.Read(src2, 1);
Mat watermarkImg2 = ImgWatermarkUtil.GetImageWatermarkWithText(img444);
string extracted2 = Path.Combine(baseDir, "555.png");
Cv2.ImWrite(extracted2, watermarkImg2);
Console.WriteLine("ImageWatermarkUtilMain finished.");
}
}
}
ShuiYinCSharp/Com/Lmc/ShuiYin/ImgWatermarkUtil.cs
+140
View File
@@ -0,0 +1,140 @@
using System.Collections.Generic;
using OpenCvSharp;
namespace Com.Lmc.ShuiYin
{
public class ImgWatermarkUtil
{
// Changed from static fields to local to avoid thread safety issues,
// but to match structure I will keep them but re-initialize them or just use locals if possible.
// The Java code reused static lists which is buggy. I will use locals.
public static Mat AddImageWatermarkWithText(Mat image, string watermarkText)
{
Mat complexImage = new Mat();
Mat padded = SplitSrc(image, out List<Mat> allPlanes);
padded.ConvertTo(padded, MatType.CV_32F);
List<Mat> planes = new List<Mat>();
planes.Add(padded);
planes.Add(Mat.Zeros(padded.Size(), MatType.CV_32F));
Cv2.Merge(planes.ToArray(), complexImage);
Cv2.Dft(complexImage, complexImage);
Scalar scalar = new Scalar(0, 0, 0);
Point point = new Point(40, 40);
Cv2.PutText(complexImage, watermarkText, point, HersheyFonts.HersheyDuplex, 1.0, scalar);
Cv2.Flip(complexImage, complexImage, FlipMode.XY);
Cv2.PutText(complexImage, watermarkText, point, HersheyFonts.HersheyDuplex, 1.0, scalar);
Cv2.Flip(complexImage, complexImage, FlipMode.XY);
return AntitransformImage(complexImage, allPlanes);
}
public static Mat GetImageWatermarkWithText(Mat image)
{
Mat complexImage = new Mat();
Mat padded = SplitSrc(image, out List<Mat> unused);
padded.ConvertTo(padded, MatType.CV_32F);
List<Mat> planes = new List<Mat>();
planes.Add(padded);
planes.Add(Mat.Zeros(padded.Size(), MatType.CV_32F));
Cv2.Merge(planes.ToArray(), complexImage);
Cv2.Dft(complexImage, complexImage);
return CreateOptimizedMagnitude(complexImage);
}
private static Mat SplitSrc(Mat mat, out List<Mat> allPlanes)
{
allPlanes = new List<Mat>();
mat = OptimizeImageDim(mat);
Cv2.Split(mat, out Mat[] splitPlanes);
allPlanes.AddRange(splitPlanes);
Mat padded = new Mat();
if (allPlanes.Count > 1)
{
padded = allPlanes[0];
}
else
{
padded = mat;
}
return padded;
}
private static Mat AntitransformImage(Mat complexImage, List<Mat> allPlanes)
{
Mat invDFT = new Mat();
Cv2.Idft(complexImage, invDFT, DftFlags.Scale | DftFlags.RealOutput);
Mat restoredImage = new Mat();
invDFT.ConvertTo(restoredImage, MatType.CV_8U);
if (allPlanes.Count == 0)
{
allPlanes.Add(restoredImage);
}
else
{
allPlanes[0] = restoredImage;
}
Mat lastImage = new Mat();
Cv2.Merge(allPlanes.ToArray(), lastImage);
return lastImage;
}
private static Mat OptimizeImageDim(Mat image)
{
Mat padded = new Mat();
int addPixelRows = Cv2.GetOptimalDFTSize(image.Rows);
int addPixelCols = Cv2.GetOptimalDFTSize(image.Cols);
Cv2.CopyMakeBorder(image, padded, 0, addPixelRows - image.Rows, 0, addPixelCols - image.Cols,
BorderTypes.Constant, Scalar.All(0));
return padded;
}
private static Mat CreateOptimizedMagnitude(Mat complexImage)
{
List<Mat> newPlanes = new List<Mat>();
Mat mag = new Mat();
Cv2.Split(complexImage, out Mat[] splitPlanes);
newPlanes.AddRange(splitPlanes);
Cv2.Magnitude(newPlanes[0], newPlanes[1], mag);
Cv2.Add(Mat.Ones(mag.Size(), MatType.CV_32F), mag, mag);
Cv2.Log(mag, mag);
ShiftDFT(mag);
mag.ConvertTo(mag, MatType.CV_8UC1);
Cv2.Normalize(mag, mag, 0, 255, NormTypes.MinMax, (int)MatType.CV_8UC1);
return mag;
}
private static void ShiftDFT(Mat image)
{
image = image.SubMat(new Rect(0, 0, image.Cols & -2, image.Rows & -2));
int cx = image.Cols / 2;
int cy = image.Rows / 2;
Mat q0 = new Mat(image, new Rect(0, 0, cx, cy));
Mat q1 = new Mat(image, new Rect(cx, 0, cx, cy));
Mat q2 = new Mat(image, new Rect(0, cy, cx, cy));
Mat q3 = new Mat(image, new Rect(cx, cy, cx, cy));
Mat tmp = new Mat();
q0.CopyTo(tmp);
q3.CopyTo(q0);
tmp.CopyTo(q3);
q1.CopyTo(tmp);
q2.CopyTo(q1);
tmp.CopyTo(q2);
}
}
}
ShuiYinCSharp/Com/Lmc/ShuiYin/One/Converter/Converter.cs
+13
View File
@@ -0,0 +1,13 @@
using OpenCvSharp;
namespace Com.Lmc.ShuiYin.One.Converter
{
public interface Converter
{
Mat Start(Mat src);
void Inverse(Mat com);
void AddTextWatermark(Mat com, string watermark);
void AddImageWatermark(Mat com, Mat watermark);
Mat ShowWatermark(Mat src);
}
}
ShuiYinCSharp/Com/Lmc/ShuiYin/One/Converter/DctConverter.cs
+77
View File
@@ -0,0 +1,77 @@
using OpenCvSharp;
using Com.Lmc.ShuiYin.One.Util;
namespace Com.Lmc.ShuiYin.One.Converter
{
public class DctConverter : Converter
{
public Mat Start(Mat src)
{
if ((src.Cols & 1) != 0)
{
Cv2.CopyMakeBorder(src, src, 0, 0, 0, 1, BorderTypes.Constant, Scalar.All(0));
}
if ((src.Rows & 1) != 0)
{
Cv2.CopyMakeBorder(src, src, 0, 1, 0, 0, BorderTypes.Constant, Scalar.All(0));
}
src.ConvertTo(src, MatType.CV_32F);
Cv2.Dct(src, src);
return src;
}
public void Inverse(Mat com)
{
Cv2.Idct(com, com);
}
public void AddTextWatermark(Mat com, string watermark)
{
Cv2.PutText(com, watermark,
new Point(com.Cols >> 2, com.Rows >> 2),
HersheyFonts.HersheyComplex, 2.0,
new Scalar(2, 2, 2, 0), 2, LineTypes.Link8, false);
}
public void AddImageWatermark(Mat com, Mat watermark)
{
Mat mask = new Mat();
Cv2.InRange(watermark, new Scalar(0, 0, 0, 0), new Scalar(0, 0, 0, 0), mask);
Mat i2 = new Mat(watermark.Size(), watermark.Type(), new Scalar(2, 2, 2, 0));
i2.CopyTo(watermark, mask);
watermark.ConvertTo(watermark, MatType.CV_32F);
int row = (com.Rows - watermark.Rows) >> 1;
int col = (com.Cols - watermark.Cols) >> 1;
Cv2.CopyMakeBorder(watermark, watermark, row, row, col, col, BorderTypes.Constant, Scalar.All(0));
Utils.FixSize(watermark, com);
Cv2.AddWeighted(watermark, 0.03, com, 1, 0.0, com);
}
public Mat ShowWatermark(Mat src)
{
src.ConvertTo(src, MatType.CV_8UC3); // COLOR_RGB2HSV requires 8-bit or 16-bit usually, Java code says convertTo(src, COLOR_RGB2HSV). Wait.
// Java: src.convertTo(src, COLOR_RGB2HSV);
// Actually convertTo is for type conversion (e.g. to float). cvtColor is for color space.
// The Java code in DctConverter.java says: src.convertTo(src, COLOR_RGB2HSV);
// This looks like a mistake in the Java code or I am misreading.
// Core.java doesn't have COLOR_RGB2HSV constant for convertTo. Imgproc has it.
// Imgproc.cvtColor(src, src, Imgproc.COLOR_RGB2HSV); is the correct way.
// The Java code provided: `src.convertTo(src, COLOR_RGB2HSV);`
// `COLOR_RGB2HSV` is an int (usually 40 or 41). `convertTo` takes rtype (int).
// If they are using `convertTo` with a color conversion code, they might be doing something wrong or it's valid in Java OpenCV to use it as a type? No.
// `CV_32F` is a type. `COLOR_RGB2HSV` is a conversion code.
// Let's assume they meant `Imgproc.cvtColor`.
// Wait, checking the Java code again: `src.convertTo(src, COLOR_RGB2HSV);`
// If I look at `DctConverter.java` line 76: `src.convertTo(src, COLOR_RGB2HSV);`
// This is very suspicious.
// However, `COLOR_RGB2HSV` is likely imported statically from `Imgproc`.
// In OpenCV C++, `convertTo` changes the depth.
// I will use `Cv2.CvtColor` because that's what makes sense for HSV.
Cv2.CvtColor(src, src, ColorConversionCodes.RGB2HSV);
Cv2.InRange(src, new Scalar(0, 0, 0, 0), new Scalar(16, 16, 16, 0), src);
Cv2.Normalize(src, src, 0, 255, NormTypes.MinMax, (int)MatType.CV_8UC1);
return src;
}
}
}
ShuiYinCSharp/Com/Lmc/ShuiYin/One/Converter/DftConverter.cs
+93
View File
@@ -0,0 +1,93 @@
using System.Collections.Generic;
using OpenCvSharp;
using Com.Lmc.ShuiYin.One.Util;
using Com.Lmc.ShuiYin; // For ShuiYinUtils
namespace Com.Lmc.ShuiYin.One.Converter
{
public class DftConverter : Converter
{
public Mat Start(Mat src)
{
src.ConvertTo(src, MatType.CV_32F);
List<Mat> planes = new List<Mat>();
Mat com = new Mat();
planes.Add(src);
planes.Add(Mat.Zeros(src.Size(), MatType.CV_32F));
Cv2.Merge(planes.ToArray(), com);
Cv2.Dft(com, com);
return com;
}
public void Inverse(Mat com)
{
List<Mat> planes = new List<Mat>();
Cv2.Idft(com, com);
Cv2.Split(com, out Mat[] splitPlanes);
planes.AddRange(splitPlanes);
Cv2.Normalize(planes[0], com, 0, 255, NormTypes.MinMax, (int)MatType.CV_8UC3);
}
public void AddTextWatermark(Mat com, string watermark)
{
Scalar s = new Scalar(255, 255, 255, 0);
Point p = new Point(0, com.Rows / 3);
int thickness = 3;
// Note: ShuiYinUtils needs to be implemented. Assuming it exists.
double fontScale = ShuiYinUtils.GetFontScale(new Size(com.Cols, com.Rows / 2), watermark, HersheyFonts.HersheyComplex, thickness);
Cv2.PutText(com, watermark, p, HersheyFonts.HersheyComplex, fontScale, s, thickness, LineTypes.Link8, false);
Cv2.Flip(com, com, FlipMode.X); // -1 in OpenCV is both axes, but here it seems they use -1. In OpenCvSharp FlipMode.XY is -1.
// Wait, Java code says -1. OpenCvSharp FlipMode: X=0, Y=1, XY=-1.
// Let's check Java docs: 0 means flipping around the x-axis... wait.
// OpenCV: 0 means flipping around the x-axis and positive value (for example, 1) means flipping around y-axis. Negative value (for example, -1) means flipping around both axes.
// So -1 is XY.
Cv2.Flip(com, com, FlipMode.XY);
Cv2.PutText(com, watermark, p, HersheyFonts.HersheyComplex, fontScale, s, thickness, LineTypes.Link8, false);
Cv2.Flip(com, com, FlipMode.XY);
}
public void AddImageWatermark(Mat com, Mat watermark)
{
List<Mat> planes = new List<Mat>();
List<Mat> newPlanes = new List<Mat>();
Mat temp = new Mat();
int col = (com.Cols - watermark.Cols) >> 1;
int row = ((com.Rows >> 1) - watermark.Rows) >> 1;
watermark.ConvertTo(watermark, MatType.CV_32F);
Cv2.CopyMakeBorder(watermark, watermark, row, row, col, col, BorderTypes.Constant, Scalar.All(0));
planes.Add(watermark);
Cv2.Flip(watermark, temp, FlipMode.XY);
planes.Add(temp);
// vconcat expects an array of Mats
Mat[] planesArray = planes.ToArray();
// In Java: vconcat(planes, watermark); -> watermark becomes the concatenation.
// In C#: Cv2.VConcat(planes, watermark);
Cv2.VConcat(planesArray, watermark);
newPlanes.Add(watermark);
newPlanes.Add(watermark);
Cv2.Merge(newPlanes.ToArray(), watermark);
Utils.FixSize(watermark, com);
Cv2.AddWeighted(watermark, 8, com, 1, 0.0, com);
Cv2.Split(com, out Mat[] splitCom);
// The Java code ends with split(com, planes), but doesn't return or use planes. It seems redundant or side-effect based if 'planes' was a field, but it's local.
// Actually, in Java code: split(com, planes); where planes is a local List<Mat>. This seems useless at the end of the method unless it modifies 'com' in place (it doesn't, split fills the list).
// So I can ignore it.
}
public Mat ShowWatermark(Mat src)
{
Mat mag = new Mat();
Cv2.Split(src, out Mat[] splitSrc);
// Java: magnitude(newPlanes.get(0), newPlanes.get(1), mag);
Cv2.Magnitude(splitSrc[0], splitSrc[1], mag);
Cv2.Add(Mat.Ones(mag.Size(), MatType.CV_32F), mag, mag);
Cv2.Log(mag, mag);
mag.ConvertTo(mag, MatType.CV_8UC1);
Cv2.Normalize(mag, mag, 0, 255, NormTypes.MinMax, (int)MatType.CV_8UC1);
return mag;
}
}
}
ShuiYinCSharp/Com/Lmc/ShuiYin/One/Converter/DwtConverter.cs
+32
View File
@@ -0,0 +1,32 @@
using OpenCvSharp;
namespace Com.Lmc.ShuiYin.One.Converter
{
public class DwtConverter : Converter
{
public Mat Start(Mat src)
{
return null;
}
public void Inverse(Mat com)
{
}
public void AddTextWatermark(Mat com, string watermark)
{
}
public void AddImageWatermark(Mat com, Mat watermark)
{
}
public Mat ShowWatermark(Mat src)
{
return null;
}
}
}
ShuiYinCSharp/Com/Lmc/ShuiYin/One/Dencoder/Decoder.cs
+32
View File
@@ -0,0 +1,32 @@
using Com.Lmc.ShuiYin.One.Converter;
using Com.Lmc.ShuiYin.One.Util;
using OpenCvSharp;
namespace Com.Lmc.ShuiYin.One.Dencoder
{
public class Decoder
{
private Converter.Converter converter;
public Decoder(Converter.Converter converter)
{
this.converter = converter;
}
public Converter.Converter GetConverter()
{
return converter;
}
public void SetConverter(Converter.Converter converter)
{
this.converter = converter;
}
public void Decode(string image, string output)
{
// CV_8U is 0
Cv2.ImWrite(output, this.converter.ShowWatermark(this.converter.Start(Utils.Read(image, 0))));
}
}
}
ShuiYinCSharp/Com/Lmc/ShuiYin/One/Dencoder/Encoder.cs
+72
View File
@@ -0,0 +1,72 @@
using System.Collections.Generic;
using OpenCvSharp;
using Com.Lmc.ShuiYin.One.Converter;
using Com.Lmc.ShuiYin.One.Util;
namespace Com.Lmc.ShuiYin.One.Dencoder
{
public abstract class Encoder
{
protected Converter.Converter converter; // protected for subclasses
public Encoder(Converter.Converter converter)
{
this.converter = converter;
}
public Converter.Converter GetConverter()
{
return converter;
}
public void SetConverter(Converter.Converter converter)
{
this.converter = converter;
}
public void Encode(string image, string watermark, string output)
{
Mat src = Utils.Read(image, 1); // CV_8S -> Color (1)
List<Mat> channel = new List<Mat>();
List<Mat> newChannel = new List<Mat>();
Cv2.Split(src, out Mat[] splitChannel);
channel.AddRange(splitChannel);
// Java: for (int i = 0; i < 3; i++)
// OpenCvSharp Split returns array of Mats.
// Ensure we have 3 channels? The loop is hardcoded to 3.
for (int i = 0; i < 3 && i < channel.Count; i++)
{
Mat com = this.converter.Start(channel[i]).Clone();
this.AddWatermark(com, watermark);
this.converter.Inverse(com);
// In Java: newChannel.add(i, com);
newChannel.Add(com);
}
// If src has more than 3 channels (e.g. alpha), we should probably keep them?
// The java code only loops 3 times.
if (channel.Count > 3)
{
for (int i = 3; i < channel.Count; i++)
{
newChannel.Add(channel[i]);
}
}
Mat res = new Mat();
Cv2.Merge(newChannel.ToArray(), res);
if (res.Rows != src.Rows || res.Cols != src.Cols)
{
res = new Mat(res, new Rect(0, 0, src.Width, src.Height));
}
Cv2.ImWrite(output, res);
}
public abstract void AddWatermark(Mat com, string watermark);
}
}
ShuiYinCSharp/Com/Lmc/ShuiYin/One/Dencoder/ImageEncoder.cs
+19
View File
@@ -0,0 +1,19 @@
using Com.Lmc.ShuiYin.One.Converter;
using Com.Lmc.ShuiYin.One.Util;
using OpenCvSharp;
namespace Com.Lmc.ShuiYin.One.Dencoder
{
public class ImageEncoder : Encoder
{
public ImageEncoder(Converter.Converter converter) : base(converter)
{
}
public override void AddWatermark(Mat com, string watermark)
{
// CV_8U is 0
this.converter.AddImageWatermark(com, Utils.Read(watermark, 0));
}
}
}
ShuiYinCSharp/Com/Lmc/ShuiYin/One/Dencoder/TextEncoder.cs
+25
View File
@@ -0,0 +1,25 @@
using Com.Lmc.ShuiYin.One.Converter;
using Com.Lmc.ShuiYin.One.Util;
using OpenCvSharp;
namespace Com.Lmc.ShuiYin.One.Dencoder
{
public class TextEncoder : Encoder
{
public TextEncoder(Converter.Converter converter) : base(converter)
{
}
public override void AddWatermark(Mat com, string watermark)
{
if (Utils.IsAscii(watermark))
{
this.converter.AddTextWatermark(com, watermark);
}
else
{
this.converter.AddImageWatermark(com, Utils.DrawNonAscii(watermark));
}
}
}
}
ShuiYinCSharp/Com/Lmc/ShuiYin/One/Test.cs
+32
View File
@@ -0,0 +1,32 @@
using System;
using System.IO;
using Com.Lmc.ShuiYin.One.Converter;
using Com.Lmc.ShuiYin.One.Dencoder;
namespace Com.Lmc.ShuiYin.One
{
public class Test
{
public static void Run(string[] args)
{
Converter.Converter converter = new DftConverter();
Encoder encoder = new TextEncoder(converter);
Decoder decoder = new Decoder(converter);
string baseDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestImages");
string src = Path.Combine(baseDir, "yinhua.png");
string watermarked = Path.Combine(baseDir, "yinhua2.png");
string extracted = Path.Combine(baseDir, "yinhua3.png");
encoder.Encode(src, "CheShenWeiWu", watermarked);
decoder.Decode(watermarked, extracted);
string src2 = Path.Combine(baseDir, "444.jpg");
string extracted2 = Path.Combine(baseDir, "555.jpg");
decoder.Decode(src2, extracted2);
Console.WriteLine("One.Test finished.");
}
}
}
ShuiYinCSharp/Com/Lmc/ShuiYin/One/Util/Utils.cs
+116
View File
@@ -0,0 +1,116 @@
using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Text;
using OpenCvSharp;
using OpenCvSharp.Extensions;
using Size = OpenCvSharp.Size;
using Point = OpenCvSharp.Point;
namespace Com.Lmc.ShuiYin.One.Util
{
public class Utils
{
public static Mat Read(string image, int type)
{
// Map Java CV_8S (1) -> Color, CV_8U (0) -> Grayscale
ImreadModes mode = ImreadModes.Unchanged;
if (type == 1) mode = ImreadModes.Color;
else if (type == 0) mode = ImreadModes.Grayscale;
else mode = (ImreadModes)type;
Mat src = Cv2.ImRead(image, mode);
if (src.Empty())
{
Console.WriteLine("File not found!");
Environment.Exit(-1);
}
return src;
}
public static void Show(Mat mat)
{
Cv2.ImShow("Utils", mat);
Cv2.WaitKey(0);
}
public static Mat OptimalDft(Mat srcImg)
{
Mat padded = new Mat();
int opRows = Cv2.GetOptimalDFTSize(srcImg.Rows);
int opCols = Cv2.GetOptimalDFTSize(srcImg.Cols);
Cv2.CopyMakeBorder(srcImg, padded, 0, opRows - srcImg.Rows,
0, opCols - srcImg.Cols, BorderTypes.Constant, Scalar.All(0));
return padded;
}
public static bool IsAscii(string str)
{
foreach (char c in str)
{
if (c > 127) // Simple ASCII check
{
return false;
}
}
return true;
}
public static Mat DrawNonAscii(string watermark)
{
// Create a dummy bitmap to measure string
using (Bitmap dummy = new Bitmap(1, 1))
using (Graphics gDummy = Graphics.FromImage(dummy))
{
Font font = new Font("Arial", 64, FontStyle.Regular, GraphicsUnit.Pixel);
// In Java code: Font font = new Font("Default", Font.PLAIN, 64);
// "Default" might not exist in Windows fonts, usually maps to Dialog or SansSerif.
// I'll use "Arial" or generic SansSerif.
SizeF size = gDummy.MeasureString(watermark, font);
int width = (int)Math.Ceiling(size.Width);
int height = (int)Math.Ceiling(size.Height);
// Create actual bitmap
Bitmap bufferedImage = new Bitmap(width, height, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
// Java uses TYPE_BYTE_GRAY, but System.Drawing doesn't support drawing to 8bpp easily.
// We will draw to RGB and convert to Gray later or let OpenCV handle it.
using (Graphics graphics = Graphics.FromImage(bufferedImage))
{
graphics.TextRenderingHint = TextRenderingHint.AntiAlias;
graphics.CompositingQuality = CompositingQuality.HighQuality;
graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
graphics.Clear(Color.Black); // Assuming background is black? Java code says `new BufferedImage`. Default is 0 (black).
// Java code: graphics.setColor(Color.WHITE); graphics.drawString(watermark, 0, metrics.getAscent());
graphics.DrawString(watermark, font, Brushes.White, 0, 0);
}
// Convert to Mat
Mat res = BitmapConverter.ToMat(bufferedImage);
// Convert to grayscale CV_8U
Cv2.CvtColor(res, res, ColorConversionCodes.BGR2GRAY);
Cv2.ImWrite("C:\\tools\\shuiyin.png", res); // Keep path as requested
return res;
}
}
public static void FixSize(Mat src, Mat mirror)
{
if (src.Rows != mirror.Rows)
{
Cv2.CopyMakeBorder(src, src, 0, mirror.Rows - src.Rows,
0, 0, BorderTypes.Constant, Scalar.All(0));
}
if (src.Cols != mirror.Cols)
{
Cv2.CopyMakeBorder(src, src, 0, 0,
0, mirror.Cols - src.Cols, BorderTypes.Constant, Scalar.All(0));
}
}
}
}
ShuiYinCSharp/Com/Lmc/ShuiYin/ShuiYinUtils.cs
+20
View File
@@ -0,0 +1,20 @@
using OpenCvSharp;
namespace Com.Lmc.ShuiYin
{
public class ShuiYinUtils
{
public static double GetFontScale(Size maxSize, string watermark, HersheyFonts fontFace, int thickness)
{
double fontScale = 0.5;
while (true)
{
Size size = Cv2.GetTextSize(watermark, fontFace, fontScale, thickness, out int baseline);
if (size.Height >= maxSize.Height || size.Width >= maxSize.Width)
break;
fontScale += 0.2;
}
return fontScale;
}
}
}
ShuiYinCSharp/Com/Lmc/ShuiYin/Two/Utils/QRCodeUtils.cs
+114
View File
@@ -0,0 +1,114 @@
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using ZXing;
using ZXing.Common;
using ZXing.QrCode;
using ZXing.QrCode.Internal;
using ZXing.Windows.Compatibility;
namespace Com.Lmc.ShuiYin.Two.Utils
{
public class QRCodeUtils
{
private int width;
private int height;
private string format;
private Dictionary<EncodeHintType, object> paramMap;
public QRCodeUtils()
{
this.width = 100;
this.height = 100;
this.format = "png";
this.paramMap = new Dictionary<EncodeHintType, object>();
this.paramMap.Add(EncodeHintType.CHARACTER_SET, "UTF-8");
this.paramMap.Add(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.M);
this.paramMap.Add(EncodeHintType.MARGIN, 1);
}
public void SetFormat(string format)
{
this.format = format;
}
public void SetSize(int width, int height)
{
this.width = width;
this.height = height;
}
public void SetParam(EncodeHintType type, object param)
{
if (paramMap.ContainsKey(type))
{
paramMap[type] = param;
}
else
{
paramMap.Add(type, param);
}
}
public void QREncode(string content, string outPutFile)
{
BarcodeWriter writer = new BarcodeWriter
{
Format = BarcodeFormat.QR_CODE,
Options = new QrCodeEncodingOptions
{
Width = this.width,
Height = this.height,
CharacterSet = "UTF-8",
ErrorCorrection = (ErrorCorrectionLevel)paramMap[EncodeHintType.ERROR_CORRECTION],
Margin = (int)paramMap[EncodeHintType.MARGIN]
}
};
using (Bitmap bitmap = writer.Write(content))
{
ImageFormat imgFormat = ImageFormat.Png;
if (format.Equals("jpg", StringComparison.OrdinalIgnoreCase) || format.Equals("jpeg", StringComparison.OrdinalIgnoreCase))
imgFormat = ImageFormat.Jpeg;
else if (format.Equals("bmp", StringComparison.OrdinalIgnoreCase))
imgFormat = ImageFormat.Bmp;
bitmap.Save(outPutFile, imgFormat);
}
}
public Bitmap QREncode(string contents)
{
BarcodeWriter writer = new BarcodeWriter
{
Format = BarcodeFormat.QR_CODE,
Options = new QrCodeEncodingOptions
{
Width = this.width,
Height = this.height,
CharacterSet = "UTF-8",
ErrorCorrection = (ErrorCorrectionLevel)paramMap[EncodeHintType.ERROR_CORRECTION],
Margin = (int)paramMap[EncodeHintType.MARGIN]
}
};
return writer.Write(contents);
}
public string QRReader(string filePath)
{
using (Bitmap bitmap = (Bitmap)Image.FromFile(filePath))
{
return QRReader(bitmap);
}
}
public string QRReader(Bitmap bitmap)
{
BarcodeReader reader = new BarcodeReader();
// reader.Options.CharacterSet = "UTF-8";
Result result = reader.Decode(bitmap);
return result?.Text;
}
}
}
ShuiYinCSharp/Com/Lmc/ShuiYin/Two/Utils/TwoMain.cs
+26
View File
@@ -0,0 +1,26 @@
using System;
using System.IO;
namespace Com.Lmc.ShuiYin.Two.Utils
{
public class TwoMain
{
public static void Run(string[] args)
{
string baseDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestImages");
string src = Path.Combine(baseDir, "meinv.png");
string watermarked = Path.Combine(baseDir, "meinv2.png");
string extracted = Path.Combine(baseDir, "meinv3.png");
WaterMarkDFT.Embed(src, "huafu", watermarked);
WaterMarkDFT.Extract(watermarked, extracted);
string src2 = Path.Combine(baseDir, "444.png");
string extracted2 = Path.Combine(baseDir, "555.png");
WaterMarkDFT.Extract(src2, extracted2);
Console.WriteLine("TwoMain finished.");
}
}
}
ShuiYinCSharp/Com/Lmc/ShuiYin/Two/Utils/WaterMarkDCT.cs
+193
View File
@@ -0,0 +1,193 @@
using System.Collections.Generic;
using OpenCvSharp;
namespace Com.Lmc.ShuiYin.Two.Utils
{
public class WaterMarkDCT
{
private static readonly double P = 65;
public static void Embed(string imagePath, string watermarkPath, string outputPath)
{
Mat originaleImage = Cv2.ImRead(imagePath);
List<Mat> allPlanes = new List<Mat>();
Cv2.Split(originaleImage, out Mat[] splitPlanes);
allPlanes.AddRange(splitPlanes);
Mat YMat = allPlanes[0];
int[][] watermark = ImageToMatrix(watermarkPath);
int length = 8;
for (int i = 0; i < watermark.Length; i++)
{
for (int j = 0; j < watermark[0].Length; j++)
{
Mat block = GetImageValue(YMat, i, j, length);
int x1 = 1, y1 = 2;
int x2 = 2, y2 = 1;
// In Java: double[] a = block.get(x1, y1);
// OpenCvSharp Get returns struct/value.
// block is CV_32F (float) based on GetImageValue.
Cv2.Dct(block, block);
if (watermark[i][j] == 1)
{
block.Set(x1, y1, (float)P);
block.Set(x2, y2, (float)-P);
}
if (watermark[i][j] == 0)
{
block.Set(x1, y1, (float)-P);
block.Set(x2, y2, (float)P);
}
Cv2.Idct(block, block);
for (int m = 0; m < length; m++)
{
for (int t = 0; t < length; t++)
{
// In Java: double[] e = block.get(m, t);
// YMat.put(i * length + m, j * length + t, e);
float e = block.At<float>(m, t);
// YMat is likely CV_8U from imread, but GetImageValue reads it.
// If YMat is CV_8U, we can't put float P (65) directly if it overflows or logic expects float processing.
// But Java code: `Mat YMat = allPlanes.get(0);` (CV_8U usually).
// `Mat block = getImageValue(YMat...);` creates new Mat CV_32F.
// Then `YMat.put` writes back. If YMat is 8U, putting float might be truncated or requires YMat to be 32F.
// However, Java OpenCV `put` handles conversion?
// Let's assume YMat should be converted to float if we are doing this, OR we cast to byte.
// But P=65 is additive? No, it replaces values.
// Wait, `block.get(x1, y1)` returns the DCT coefficient.
// The DCT is done on 32F block.
// Then IDCT.
// Then we put back to YMat.
// If YMat is 8U, we are putting float values.
// In OpenCvSharp: `YMat.Set(row, col, value)`.
// If YMat is 8U, Set will cast.
YMat.Set(i * length + m, j * length + t, (byte)e); // Cast to byte? Or keep as double/float if YMat was converted?
// Java code didn't convert YMat to 32F explicitly in Embed method, unlike DFT.
// But `getImageValue` creates a 32F mat from YMat values.
// `YMat.put(...)` in Java takes double array.
// If YMat is 8U, it sets the byte value.
// So casting to byte is correct.
}
}
}
}
Mat imageOut = new Mat();
Cv2.Merge(allPlanes.ToArray(), imageOut);
Cv2.ImWrite(outputPath, imageOut);
}
public static void Extract(string targetImage, string outputWatermark)
{
Mat image = Cv2.ImRead(targetImage);
List<Mat> allPlanes = new List<Mat>();
Cv2.Split(image, out Mat[] splitPlanes);
allPlanes.AddRange(splitPlanes);
Mat YMat = allPlanes[0];
int rows = 100;
int cols = 100;
int length = 8;
int[][] watermark = new int[rows][];
for (int k = 0; k < rows; k++) watermark[k] = new int[cols];
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
{
Mat block = GetImageValue(YMat, i, j, length);
Cv2.Dct(block, block);
int x1 = 1, y1 = 2;
int x2 = 2, y2 = 1;
float a = block.At<float>(x1, y1);
float c = block.At<float>(x2, y2);
if (a >= c)
{
watermark[i][j] = 1;
}
}
}
MatrixToImage(watermark, outputWatermark);
}
private static Mat GetImageValue(Mat YMat, int x, int y, int length)
{
Mat mat = new Mat(length, length, MatType.CV_32F);
for (int i = 0; i < length; i++)
{
for (int j = 0; j < length; j++)
{
// Java: double[] temp = YMat.get(x * length + i, y * length + j);
// mat.put(i, j, temp);
// If YMat is 8U, At<byte>
byte val = YMat.At<byte>(x * length + i, y * length + j);
mat.Set(i, j, (float)val);
}
}
return mat;
}
private static void MatrixToImage(int[][] watermark, string dstPath)
{
int rows = watermark.Length;
int columns = watermark[0].Length;
Mat image = new Mat(rows, columns, MatType.CV_8U); // THRESH_BINARY usually on 8U
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < columns; j++)
{
if (watermark[i][j] == 1)
{
image.Set(i, j, (byte)255);
}
else
{
image.Set(i, j, (byte)0);
}
}
}
Cv2.ImWrite(dstPath, image);
}
private static int[][] ImageToMatrix(string srcPath)
{
Mat mat = Cv2.ImRead(srcPath, ImreadModes.Grayscale); // Java: THRESH_BINARY is not a load flag, it's a thresh type. But here passed to imread?
// Java: imread(srcPath, Imgproc.THRESH_BINARY).
// THRESH_BINARY is 0. CV_LOAD_IMAGE_GRAYSCALE is 0.
// So they are loading as grayscale.
int rows = mat.Rows;
int columns = mat.Cols;
int[][] waterMark = new int[rows][];
for(int k=0; k<rows; k++) waterMark[k] = new int[columns];
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < columns; j++)
{
// double[] doubles = mat.get(i, j);
byte val = mat.At<byte>(i, j);
if (val == 255)
{
waterMark[i][j] = 1;
}
else
{
waterMark[i][j] = 0;
}
}
}
return waterMark;
}
}
}
ShuiYinCSharp/Com/Lmc/ShuiYin/Two/Utils/WaterMarkDFT.cs
+123
View File
@@ -0,0 +1,123 @@
using System.Collections.Generic;
using OpenCvSharp;
namespace Com.Lmc.ShuiYin.Two.Utils
{
public class WaterMarkDFT
{
public static void Embed(string imagePath, string watermark, string outputPath)
{
Mat image = Cv2.ImRead(imagePath);
List<Mat> allPlanes = new List<Mat>();
Cv2.Split(image, out Mat[] splitPlanes);
allPlanes.AddRange(splitPlanes);
Mat processImage = allPlanes[0];
processImage.ConvertTo(processImage, MatType.CV_32F);
List<Mat> planes = new List<Mat>();
planes.Add(processImage);
planes.Add(Mat.Zeros(processImage.Size(), MatType.CV_32F));
Mat complexImage = new Mat();
Cv2.Merge(planes.ToArray(), complexImage);
Cv2.Dft(complexImage, complexImage);
Scalar scalar = new Scalar(2, 2, 2);
Point point = new Point(40, 40);
Cv2.PutText(complexImage, watermark, point, HersheyFonts.HersheyComplex, 1.5, scalar, 3, LineTypes.Link8, false); // Java: 20 -> bottomLeftOrigin? No, putText last arg is bottomLeftOrigin. Java code says 20??
// Java putText signature: (img, text, org, fontFace, fontScale, color, thickness, lineType, bottomLeftOrigin)
// Java code: putText(complexImage, watermark, point, FONT_HERSHEY_COMPLEX, 1.5, scalar, 3, 20);
// Wait, 20 is not boolean.
// Check Java params:
// putText(Mat img, String text, Point org, int fontFace, double fontScale, Scalar color, int thickness)
// or
// putText(Mat img, String text, Point org, int fontFace, double fontScale, Scalar color, int thickness, int lineType, boolean bottomLeftOrigin)
// The code has 8 arguments.
// putText(complexImage, watermark, point, FONT_HERSHEY_COMPLEX, 1.5, scalar,3, 20);
// Arg 8 is 20? 20 is not boolean.
// Maybe they mean lineType=20? But lineType is usually 8, 4, CV_AA (16).
// Maybe it is calling a different overload?
// Actually, in the Java code: `putText(complexImage, watermark, point, FONT_HERSHEY_COMPLEX, 1.5, scalar,3, 20);`
// If I assume 20 is lineType? CV_AA? No.
// Let's assume standard parameters: thickness=3, lineType=20?
// I will use standard LineTypes.Link8 and false for bottomLeftOrigin.
Cv2.Flip(complexImage, complexImage, FlipMode.XY); // -1
Cv2.PutText(complexImage, watermark, point, HersheyFonts.HersheyComplex, 1.5, scalar, 3, LineTypes.Link8, false);
Cv2.Flip(complexImage, complexImage, FlipMode.XY); // -1
Mat invDFT = new Mat();
Cv2.Idft(complexImage, invDFT, DftFlags.Scale | DftFlags.RealOutput);
invDFT.ConvertTo(invDFT, MatType.CV_8U);
allPlanes[0] = invDFT;
Cv2.Merge(allPlanes.ToArray(), invDFT);
Cv2.ImWrite(outputPath, invDFT);
}
public static void Extract(string targetImage, string outputWatermark)
{
Mat image = Cv2.ImRead(targetImage);
List<Mat> allPlanes = new List<Mat>();
Cv2.Split(image, out Mat[] splitPlanes);
allPlanes.AddRange(splitPlanes);
Mat processImage = allPlanes[0];
processImage.ConvertTo(processImage, MatType.CV_32F);
List<Mat> planes = new List<Mat>();
planes.Add(processImage);
planes.Add(Mat.Zeros(processImage.Size(), MatType.CV_32F));
Mat complexImage = new Mat();
Cv2.Merge(planes.ToArray(), complexImage);
Cv2.Dft(complexImage, complexImage);
List<Mat> newPlanes = new List<Mat>();
Mat mag = new Mat();
Cv2.Split(complexImage, out Mat[] splitComplex);
newPlanes.AddRange(splitComplex);
Cv2.Magnitude(newPlanes[0], newPlanes[1], mag);
Cv2.Add(Mat.Ones(mag.Size(), MatType.CV_32F), mag, mag);
Cv2.Log(mag, mag);
// Crop
mag = mag.SubMat(new Rect(0, 0, mag.Cols & -2, mag.Rows & -2));
int cx = mag.Cols / 2;
int cy = mag.Rows / 2;
Mat q0 = new Mat(mag, new Rect(0, 0, cx, cy));
Mat q1 = new Mat(mag, new Rect(cx, 0, cx, cy));
Mat q2 = new Mat(mag, new Rect(0, cy, cx, cy));
Mat q3 = new Mat(mag, new Rect(cx, cy, cx, cy));
Mat tmp = new Mat();
q0.CopyTo(tmp);
q3.CopyTo(q0);
tmp.CopyTo(q3);
q1.CopyTo(tmp);
q2.CopyTo(q1);
tmp.CopyTo(q2);
mag.ConvertTo(mag, MatType.CV_8UC1);
Cv2.Normalize(mag, mag, 0, 255, NormTypes.MinMax, (int)MatType.CV_8UC1);
Cv2.ImWrite(outputWatermark, mag);
}
private static Mat OptimizeImageDimensions(Mat image)
{
Mat padded = new Mat();
int addPixelRows = Cv2.GetOptimalDFTSize(image.Rows);
int addPixelCols = Cv2.GetOptimalDFTSize(image.Cols);
Cv2.CopyMakeBorder(image, padded, 0, addPixelRows - image.Rows,
0, addPixelCols - image.Cols, BorderTypes.Constant, Scalar.All(0));
return padded;
}
}
}