public Scalar getColor()
{
if (average.Val0 != -1)
{
return(average);
}
MatOfByte3 mat3 = new MatOfByte3(data);
var indexer = mat3.GetIndexer();
ArrayList hue = new ArrayList();
ArrayList light = new ArrayList();
ArrayList sat = new ArrayList();
for (int y = 0; y < data.Height; y++)
{
for (int x = 0; x < data.Width; x++)
{
Vec3b color = indexer[y, x];
hue.Add(color.Item0);
light.Add(color.Item1);
sat.Add(color.Item2);
}
}
byte medHue = getMedian(hue);
byte medLight = getMedian(light);
byte medSat = getMedian(sat);
average = new Scalar(medHue, medLight, medSat);
return(average);
}
public void Absdiff_mask(ref Mat dst, Mat src1, Mat src2, Mat mask)
{
var indexer1 = new MatOfByte3(src1).GetIndexer();
var indexer2 = new MatOfByte3(src2).GetIndexer();
var indexer_mask = new MatOfByte3(mask).GetIndexer();
var indexer_dst = new MatOfByte3(dst).GetIndexer();
for (int x = 0; x < dst.Width; x++)
{
for (int y = 0; y < dst.Height; y++)
{
int color1 = indexer1[y, x].Item0;
int color2 = indexer2[y, x].Item0;
int color_mask = indexer_mask[y, x].Item0;
var color = indexer_mask[y, x];
if (indexer_mask[y, x].Item0 == 0)//マスク画像の黒領域
{
color.Item0 = (byte)Math.Abs(color1 - color2);
}
else
{
color.Item0 = 0;//白領域は比較しない
}
indexer_dst[y, x] = color;
}
}
indexer1 = null;
indexer2 = null;
indexer_mask = null;
indexer_dst = null;
}
public static IList <YoloBoundingBox> ObtainBoundingBoxes(string base64Image)
{
var opencvImage = Image.ConvertFromBase64ToMat(base64Image);
MatOfByte3 mat3 = new MatOfByte3(opencvImage);
var indexer = mat3.GetIndexer();
Tensor <float> imageData = new DenseTensor <float>(new[] { 3, opencvImage.Width, opencvImage.Height });
for (int y = 0; y < opencvImage.Height; y++)
{
for (int x = 0; x < opencvImage.Width; x++)
{
Vec3b color = indexer[y, x];
imageData[0, y, x] = (float)color.Item2;
imageData[1, y, x] = (float)color.Item1;
imageData[2, y, x] = (float)color.Item0;
}
}
var yoloParser = new YoloParser();
var resultTransform = imageData.Reshape(new ReadOnlySpan <int>(new[] { 3 * 416 * 416 }));
var yoloModel = new YoloModel();
var results = yoloModel.Evaluate(new[] { resultTransform });
var boundingBoxes = yoloParser.ParseOutputs(results.First().ToArray());
return(boundingBoxes);
}
public void brightness(ref Mat img, double 目標)
{
//中心近くの9ピクセルから輝度調整
int width = img.Width;
int height = img.Height;
int center_x = width / 5;
int center_y = height / 5;
double[] vals = new double[9];
double average = 0;
double diff = 0;
var indexer = new MatOfByte3(img).GetIndexer();
vals[0] = indexer[center_y - 10, center_x - 10].Item0; vals[3] = indexer[center_y - 10, center_x].Item0; vals[6] = indexer[center_y - 10, center_x + 10].Item0;
vals[1] = indexer[center_y, center_x - 10].Item0; vals[4] = indexer[center_y, center_x].Item0; vals[7] = indexer[center_y, center_x + 10].Item0;
vals[2] = indexer[center_y + 10, center_x - 10].Item0; vals[5] = indexer[center_y + 10, center_x].Item0; vals[8] = indexer[center_y + 10, center_x + 10].Item0;
for (int num = 0; num < 9; num++) average += vals[num];
average = average / 9.0;
diff = 目標 - average;
for (int x = 0; x < width; x++)
for (int y = 0; y < height; y++)
{
Vec3b color = indexer[y, x];
double val = color.Item0 + diff;
if (val > 255) color.Item0 = 255;
else if (val < 0) color.Item0 = 0;
else color.Item0 = (byte)val;
indexer[y, x] = color;
}
indexer = null;
}
/// <summary>
/// 访问像素
/// </summary>
public static void AccessPixel()
{
using (Mat mat = new Mat("Images/lena.jpg", ImreadModes.Color))
{
//bgr格式
using (MatOfByte3 mat3 = new MatOfByte3(mat))
{
var indexer = mat3.GetIndexer();
for (int y = 0; y < mat.Height; y++)
{
for (int x = 0; x < mat.Width; x++)
{
Vec3b color = indexer[y, x];
byte temp = color.Item0;
color.Item0 = color.Item2;//B <-- R
color.Item2 = temp;
indexer[y, x] = color;
}
}
}
using (new Window("window", mat))
{
Cv2.WaitKey();
}
}
}
public void コントラスト調整(ref Mat src, double 率)
{
int width = src.Width;
int height = src.Height;
var indexer = new MatOfByte3(src).GetIndexer();
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
Vec3b color = indexer[y, x];
double val = color.Item0 * 率;
if (val > 255)
{
color.Item0 = 255;
}
else if (val < 0)
{
color.Item0 = 0;
}
else
{
color.Item0 = (byte)val;
}
indexer[y, x] = color;
}
}
indexer = null;
}
public static IList <BoundingBox> ObtainBoundingBoxes(string base64Image)
{
var opencvImage = Image.ConvertFromBase64ToMat(base64Image);
var tensor = new DenseTensor <float>(new int[] { channels, opencvImage.Height, opencvImage.Width });
using (var mat = new MatOfByte3(opencvImage))
{
var indexer = mat.GetIndexer();
for (int y = 0; y < opencvImage.Height; y++)
{
for (int x = 0; x < opencvImage.Width; x++)
{
Vec3b color = indexer[y, x];
tensor[0, y, x] = (float)color.Item2;
tensor[1, y, x] = (float)color.Item1;
tensor[2, y, x] = (float)color.Item0;
}
}
}
var transform = tensor.Reshape(new ReadOnlySpan <int>(new[] { channels *opencvImage.Height *opencvImage.Width }));
var yoloParser = new YoloOutputParser();
var yoloModel = YoloModel.Instance;
var results = yoloModel.Evaluate(new[] { transform });
return(yoloParser.ParseOutputs(results.First().ToArray()));
}
/// <summary>
/// Calculate the Block Mean Value Based Image Perceptual Hash
/// </summary>
/// <param name="image">image to hash (OpenCV Mat)</param>
/// <param name="bits">number of blocks to divide the image by horizontally and vertically</param>
/// <returns>hash bitstring</returns>
/// <remarks>
/// based on blockhash_quick https://github.com/commonsmachinery/blockhash/blob/master/blockhash.c
/// </remarks>
/// <seealso cref="http://dx.doi.org/10.1109/IIH-MSP.2006.265125"/>
private static string BlockHash(Mat image, int bits = 8)
{
int x, y, ix, iy;
int value;
int block_width;
int block_height;
int[] blocks;
// use smaller image to speedup calculation (default 64x64)
if (image.Width != 8 * bits || image.Height != 8 * bits)
{
var smaller = new OpenCvSharp.Size(8 * bits, 8 * bits);
var simage = image.Resize(smaller, 0, 0, InterpolationFlags.Linear);
simage.CopyTo(image);
simage.Dispose();
}
var image_byte3 = new MatOfByte3(image);
var indexer = image_byte3.GetIndexer();
block_width = (image.Width) / bits;
block_height = (image.Height) / bits;
blocks = new int[bits * bits];
for (y = 0; y < bits; y++)
{
for (x = 0; x < bits; x++)
{
value = 0;
for (iy = 0; iy < block_height; iy++)
{
value = 0;
for (ix = 0; ix < block_width; ix++)
{
var iix = (x * block_width + ix);
var iiy = (y * block_height + iy);
value += (int)((double)indexer[iiy, iix].Item2 + (double)indexer[iiy, iix].Item1 + (double)indexer[iiy, iix].Item0);
}
}
blocks[y * bits + x] = value;
}
}
var hash = translate_blocks_to_bits(blocks, bits * bits, block_width * block_height);
//return bits_to_hexhash(hash);
return(hash);
}
public override void Draw(IVncPixelGetter a_pixelGetter, MatOfByte3 a_mat)
{
Scalar background = (Scalar)a_pixelGetter.GetPixelVec3b(Background, 0);
a_mat.Rectangle(new Rect(X, Y, Width, Height), background, -1 /* Fill */);
foreach (var v in Subrectangle)
{
Scalar pixelValue = (Scalar)a_pixelGetter.GetPixelVec3b(v.PixelBinary, 0);
a_mat.Rectangle(new Rect(X + v.X, Y + v.Y, v.Width, v.Height), pixelValue, -1 /* Fill */);
}
}
public Vec3b GetPixelColor(Mat image, Point p)
{
if (image.Type() != MatType.CV_8UC3)
{
throw new ArgumentException("Only CV_8UC3 images are supported...");
}
MatOfByte3 mob3 = new MatOfByte3(image);
var indexer = mob3.GetIndexer();
Vec3b color = indexer[p.Y, p.X];
return(color);
}
public static float[] GetArray(this Mat self, float[] buffer = null, bool bgr2rgb = true)
{
int width = self.Width;
int height = self.Height;
float[] f;
if (buffer == null)
{
f = new float[width * height * self.Channel];
}
else
{
if (buffer.Length < width * height * self.Channel)
{
throw new ArgumentOutOfRangeException(nameof(buffer));
}
f = buffer;
}
using (MatOfByte3 matByte = new MatOfByte3())
{
self.CopyTo(matByte);
var indexer = matByte.GetIndexer();
int i = 0;
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
Vec3b color = indexer[y, x];
if (bgr2rgb)
{
f[i] = color.Item2;
i++;
f[i] = color.Item1;
i++;
f[i] = color.Item0;
i++;
}
else
{
f[i] = color.Item0;
i++;
f[i] = color.Item1;
i++;
f[i] = color.Item2;
i++;
}
}
}
}
return(f);
}
// Copies in-memory pixels out of an OpenCV Mat into a PixData that Tesseract / Leptonica understands
private unsafe void TransferData(MatOfByte3 mat3, PixData pixData)
{
var indexer = mat3.GetIndexer();
for (int y = 0; y < mat3.Height; y++)
{
uint *pixLine = (uint *)pixData.Data + (y * pixData.WordsPerLine);
for (int x = 0; x < mat3.Width; x++)
{
Vec3b color = indexer[y, x];
PixData.SetDataFourByte(pixLine, x, BitmapHelper.EncodeAsRGBA(color.Item0, color.Item1, color.Item2, 255));
}
}
}
public override void Draw(IVncPixelGetter a_pixelGetter, MatOfByte3 a_mat)
{
var indexer = a_mat.GetIndexer();
int byteSize = a_pixelGetter.GetPixelByteSize();
int offset = m_offset;
for (int y = Y; y < Y + Height; ++y)
{
for (int x = X; x < X + Width; ++x)
{
indexer[y, x] = a_pixelGetter.GetPixelVec3b(m_pixelData, offset);
offset += byteSize;
}
}
}
public override void Draw(IVncPixelGetter a_pixelGetter, MatOfByte3 a_mat)
{
int tile = 0;
for (int y = Y; y < Y + Height; y += 16)
{
int h = (Y + Height - y) > 16 ? 16 : (Y + Height - y);
for (int x = X; x < X + Width; x += 16)
{
int w = (X + Width - x) > 16 ? 16 : (X + Width - x);
Hextile[tile].DrawHexTile(x, y, w, h, a_pixelGetter, a_mat);
++tile;
}
}
}
public void 明るさ調整(ref Mat img, double 目標)
{//中心近くの9ピクセルから輝度調整
int width = img.Width;
int height = img.Height;
int center_x = width / 5;
int center_y = height / 5;
//var indexer = img.GetGenericIndexer<Vec3b>();
double[] vals = new double[9];
double average = 0;
double diff = 0;
var indexer = new MatOfByte3(img).GetIndexer();
vals[0] = indexer[center_y - 10, center_x - 10].Item0; vals[3] = indexer[center_y - 10, center_x].Item0; vals[6] = indexer[center_y - 10, center_x + 10].Item0;
vals[1] = indexer[center_y, center_x - 10].Item0; vals[4] = indexer[center_y, center_x].Item0; vals[7] = indexer[center_y, center_x + 10].Item0;
vals[2] = indexer[center_y + 10, center_x - 10].Item0; vals[5] = indexer[center_y + 10, center_x].Item0; vals[8] = indexer[center_y + 10, center_x + 10].Item0;
for (int num = 0; num < 9; num++)
{
average += vals[num];
}
average = average / 9.0;
diff = 目標 - average;
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
Vec3b color = indexer[y, x];//indexer[y, x];
double val = color.Item0 + diff;
if (val > 255)
{
color.Item0 = 255;
}
else if (val < 0)
{
color.Item0 = 0;
}
else
{
color.Item0 = (byte)val;
}
indexer[y, x] = color;//indexer[y, x] = color;
}
}
indexer = null;
}
private int OCRNumber(Mat skillValue, string name = "")
{
if (!string.IsNullOrEmpty(name))
{
//skillValue.SaveImage($"{name}.png");
}
Pix pix;
if (skillValue.Type() == MatType.CV_8UC3)
{
// 3 bytes
pix = Pix.Create(skillValue.Width, skillValue.Height, 32);
pix.XRes = 72;
pix.YRes = 72;
PixData pixData = null;
try
{
pixData = pix.GetData();
MatOfByte3 mat3 = new MatOfByte3(skillValue);
TransferData(mat3, pixData);
}
catch (Exception)
{
pix.Dispose();
//throw;
return(0);
}
}
else
{
skillValue.SaveImage("temp.png");
pix = Pix.LoadFromFile("temp.png");
}
using (Page resultPage = _tessEngine.Process(pix))
{
string data = resultPage.GetText();
if (int.TryParse(data, out int result))
{
return(result);
}
}
return(0);
}
public static bool[] BrainInputFromMat(Mat mat)
{
var byte3Col = new MatOfByte3(mat);
var indexer = byte3Col.GetIndexer();
var pixel = indexer[0, 1];
var result = new bool[mat.Height * mat.Width];
for (int x = 0; x < mat.Width; x++)
{
for (int y = 0; y < mat.Height; y++)
{
result[(mat.Width * y) + x] = GetIndexerValue(indexer[y, x]);
}
}
return(result);
}
public void Zero(ref Mat src)
{
var indexer = new MatOfByte3(src).GetIndexer();
for (int x = 0; x < src.Width; x++)
{
for (int y = 0; y < src.Height; y++)
{
Vec3b color = indexer[y, x];
color.Item0 = 0;
color.Item1 = 0;
color.Item2 = 0;
indexer[y, x] = color;
}
}
indexer = null;
}
public static void GrayScale(Mat mat)
{
var mat3 = new MatOfByte3(mat);
var indexer = mat3.GetIndexer();
for (int y = 0; y < mat.Height; y++)
{
for (int x = 0; x < mat.Width; x++)
{
Vec3b color = indexer[y, x];
var sum = color.Item0 + color.Item1 + color.Item2;
color.Item0 = (byte)(sum / 3);
color.Item1 = (byte)(sum / 3);
color.Item2 = (byte)(sum / 3);
indexer[y, x] = color;
}
}
}
public Dictionary <string, BitmapSource> SplitColoredQR(Mat combinedMat)
{
Dictionary <string, BitmapSource> outputSplitImages = new Dictionary <string, BitmapSource>();
Size size = new Size(combinedMat.Width, combinedMat.Height);
int depth = combinedMat.Depth();
Mat redComponent = Mat.Zeros(size, MatType.CV_8UC1);
Mat grnComponent = Mat.Zeros(size, MatType.CV_8UC1);
Mat bluComponent = Mat.Zeros(size, MatType.CV_8UC1);
// Get mat indexers
MatOfByte3 mobComb = new MatOfByte3(combinedMat);
MatOfByte mobRed = new MatOfByte(redComponent);
MatOfByte mobGrn = new MatOfByte(grnComponent);
MatOfByte mobBlu = new MatOfByte(bluComponent);
MatIndexer <Vec3b> indexerComb = mobComb.GetIndexer();
MatIndexer <byte> indexerRed = mobRed.GetIndexer();
MatIndexer <byte> indexerGrn = mobGrn.GetIndexer();
MatIndexer <byte> indexerBlu = mobBlu.GetIndexer();
for (int y = 0; y < combinedMat.Height; y++)
{
for (int x = 0; x < combinedMat.Width; x++)
{
// Assign intensity of red channel from the combined mat to the red component mat
indexerRed[y, x] = indexerComb[y, x].Item2;
// Assign intensity of green channel from the combined mat to the green component mat
indexerGrn[y, x] = indexerComb[y, x].Item1;
// Assign intensity of blue channel from the combined mat to the blue component mat
indexerBlu[y, x] = indexerComb[y, x].Item0;
}
}
outputSplitImages.Add(QR_TYPE_RED_OUT, Utils.MatToImage(redComponent));
outputSplitImages.Add(QR_TYPE_GREEN_OUT, Utils.MatToImage(grnComponent));
outputSplitImages.Add(QR_TYPE_BLUE_OUT, Utils.MatToImage(bluComponent));
return(outputSplitImages);
}
public static void Binarization(Mat mat, float threshold)
{
var mat3 = new MatOfByte3(mat);
var indexer = mat3.GetIndexer();
var bthreshold = threshold * byte.MaxValue;
for (int y = 0; y < mat.Height; y++)
{
for (int x = 0; x < mat.Width; x++)
{
Vec3b color = indexer[y, x];
var sum = color.Item0 + color.Item1 + color.Item2;
color.Item0 = (byte)(sum / 3) <= bthreshold ? byte.MinValue : byte.MaxValue;
color.Item1 = (byte)(sum / 3) <= bthreshold ? byte.MinValue : byte.MaxValue;
color.Item2 = (byte)(sum / 3) <= bthreshold ? byte.MinValue : byte.MaxValue;
indexer[y, x] = color;
}
}
}
/// <summary>
/// Faster
/// </summary>
private void TypeSpecificMat()
{
using (Mat mat = new Mat(FilePath.Lenna, LoadMode.Color))
{
MatOfByte3 mat3 = new MatOfByte3(mat);
var indexer = mat3.GetIndexer();
for (int y = 0; y < mat.Height; y++)
{
for (int x = 0; x < mat.Width; x++)
{
Vec3b color = indexer[y, x];
Swap(ref color.Item0, ref color.Item2);
indexer[y, x] = color;
}
}
//Cv2.ImShow("TypeSpecificMat", mat);
//Cv2.WaitKey(0);
//Cv2.DestroyAllWindows();
}
}
private Array2D <RgbPixel> ToArray(Mat mat)
{
var array = new Array2D <RgbPixel>(mat.Rows, mat.Cols);
using (var mat3 = new MatOfByte3(mat))
{
var indexer = mat3.GetIndexer();
for (var i = 0; i < array.Rows; i++)
{
var destRow = array[i];
for (var j = 0; j < array.Columns; j++)
{
var color = indexer[i, j];
destRow[j] = new RgbPixel(color.Item2, color.Item1, color.Item0);
}
}
}
return(array);
}
public static Color[] ConvertMatToColorArray(Mat mat)
{
var mat3b = new MatOfByte3(mat);
var indexer = mat3b.GetIndexer();
var width = mat.Width;
var heigth = mat.Height;
var colorArray = new Color[width * heigth];
for (var y = 0; y < heigth; y++)
{
for (var x = 0; x < width; x++)
{
var newColor = new Color();
newColor.r = indexer[y, x].Item2 / 255.0f;
newColor.g = indexer[y, x].Item1 / 255.0f;
newColor.b = indexer[y, x].Item0 / 255.0f;
colorArray[y * width + x] = newColor;
}
}
return(colorArray);
}
public override void Draw(IVncPixelGetter a_pixelGetter, MatOfByte3 a_mat)
{
Rect srcRect = new Rect(SrcX, SrcY, Width, Height);
Rect dstRect = new Rect(X, Y, Width, Height);
if (srcRect.IntersectsWith(dstRect))
{
using (var src = a_mat.Clone(srcRect))
using (var dst = new MatOfByte3(a_mat, dstRect))
{
src.CopyTo(dst);
}
}
else
{
using (var src = new MatOfByte3(a_mat, srcRect))
using (var dst = new MatOfByte3(a_mat, dstRect))
{
src.CopyTo(dst);
}
}
}
public void paint_black(ref Mat src, Mat mask)//maskの白領域をsrcの上に黒塗り
{
var indexer_src = new MatOfByte3(src).GetIndexer();
var indexer_mask = new MatOfByte3(mask).GetIndexer();
for (int x = 0; x < src.Width; x++)
{
for (int y = 0; y < src.Height; y++)
{
int color_src = indexer_src[y, x].Item0;
int color_mask = indexer_mask[y, x].Item0;
var color = indexer_src[y, x];
if (indexer_mask[y, x].Item0 != 0)//マスク画像の白領域
{
color.Item0 = 0;
}
indexer_src[y, x] = color;
}
}
indexer_src = null;
indexer_mask = null;
}
static float[] convert_to_channel_first(Mat mat, float[] offsets)
{
var num_pixels = mat.Size().Height *mat.Size().Width;
float[] result = new float[num_pixels * 3];
MatOfByte3 mat3 = new MatOfByte3(mat);
var indexer = mat3.GetIndexer();
var pos = 0;
for (int y = 0; y < mat.Height; y++)
{
for (int x = 0; x < mat.Width; x++)
{
var color = indexer[y, x];
result[pos] = color.Item0 - offsets[0];
result[pos + num_pixels] = color.Item1 - offsets[1];
result[pos + 2 * num_pixels] = color.Item2 - offsets[2];
pos++;
}
}
mat3.Dispose(); mat3 = null;
return(result);
}
/// <summary>
/// Convert an image to a 1-dimensional float array. All color frames
/// are laid out sequentially, one after the other.
/// </summary>
/// <param name="mat">The input image as an OpenCv Mat object.</param>
/// <param name="offsets">Offsets to apply to each color channel.</param>
/// <returns>An 1-dimensional float array containing the image data.</returns>
public static float[] FlattenByChannel(Mat mat, float[] offsets)
{
var num_pixels = mat.Size().Height *mat.Size().Width;
float[] result = new float[num_pixels * 3];
using (MatOfByte3 mat3 = new MatOfByte3(mat))
{
var indexer = mat3.GetIndexer();
var pos = 0;
for (int y = 0; y < mat.Height; y++)
{
for (int x = 0; x < mat.Width; x++)
{
var color = indexer[y, x];
result[pos] = color.Item0 - offsets[0];
result[pos + num_pixels] = color.Item1 - offsets[1];
result[pos + 2 * num_pixels] = color.Item2 - offsets[2];
pos++;
}
}
}
return(result);
}
public void WriteBackwardBody(MatOfByte3 a_mat, MemoryStream a_output)
{
// 12 == x(2) + y(2) + w(2) + h(2) + encodeType(4)
a_output.Write(BigEndianBitConverter.GetBytes(X), 0, 2);
a_output.Write(BigEndianBitConverter.GetBytes(Y), 0, 2);
a_output.Write(BigEndianBitConverter.GetBytes(Width), 0, 2);
a_output.Write(BigEndianBitConverter.GetBytes(Height), 0, 2);
a_output.Write(BigEndianBitConverter.GetBytes((Int32)VncEnum.EncodeType.Raw), 0, 4);
var indexer = a_mat.GetIndexer();
for (int y = Y; y < Y + Height; ++y)
{
for (int x = X; x < X + Width; ++x)
{
var bgr = indexer[y, x];
a_output.WriteByte(bgr.Item0);
a_output.WriteByte(bgr.Item1);
a_output.WriteByte(bgr.Item2);
a_output.WriteByte(255);
}
}
}
private Mat AlterMat(Mat mat)
{
var copy = new Mat();
mat.CopyTo(copy);
// Slowest way
//for (int i = 0; i < copy.Height; i++)
//{
// for (int j = 0; j < copy.Width; j++)
// {
// var pixel = copy.Get<Vec3b>(i, j);
// pixel.Item0 = pixel.Item2;
// copy.Set(i, j, pixel);
// }
//}
// Faster way
var fasterCopy = new MatOfByte3(mat);
var indexer = fasterCopy.GetIndexer();
for (int row = 0; row < fasterCopy.Height; row++)
{
for (int col = 0; col < fasterCopy.Width; col++)
{
var pixel = indexer[row, col];
if (50 < pixel.Item2 && pixel.Item2 < 110 && 10 < pixel.Item1 && pixel.Item1 < 100)
{
pixel.Item2 = 255;
pixel.Item1 = 0;
}
indexer[row, col] = pixel;
}
}
return(fasterCopy);
}
public void 自作反射光除去(Mat[] images, ref Mat DST)
{
int width = images[0].Width;
int height = images[0].Height;
MatIndexer <Vec3b>[] indexers = new MatIndexer <Vec3b> [4];
var indexer = new MatOfByte3(DST).GetIndexer();
for (int i = 0; i < 4; i++)
{
indexers[i] = new MatOfByte3(images[i]).GetIndexer(); //images[i].GetGenericIndexer<Vec3b>();
}
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
Vec3b[] colors = new Vec3b[4];
Vec3b color = indexer[y, x];
for (int i = 0; i < 4; i++)
{
colors[i] = indexers[i][y, x];
}
double[] vals = { 0, 0, 0, 0 };
for (int num = 0; num < 4; num++)
{
vals[num] = colors[num].Item0;
}
Array.Sort(vals);//並び替えを行う．min=vals[0]
color.Item0 = (byte)((vals[0] + vals[1] + vals[2]) / 3.0);
indexer[y, x] = color;
colors = null;
}
}
indexers = null;
indexer = null;
}
/// <summary>
/// Draws all blobs to the specified image.
/// </summary>
/// <param name="img">The target image to be drawn.</param>
public void RenderBlobs(Mat img)
{
if (img == null)
throw new ArgumentNullException("img");
/*
if (img.Empty())
throw new ArgumentException("img is empty");
if (img.Type() != MatType.CV_8UC3)
throw new ArgumentException("img must be CV_8UC3");*/
if (Blobs == null || Blobs.Count == 0)
throw new OpenCvSharpException("Blobs is empty");
if (Labels == null)
throw new OpenCvSharpException("Labels is empty");
int height = Labels.GetLength(0);
int width = Labels.GetLength(1);
img.Create(new Size(width, height), MatType.CV_8UC3);
Scalar[] colors = new Scalar[Blobs.Count];
colors[0] = Scalar.All(0);
for (int i = 1; i < Blobs.Count; i++)
{
colors[i] = Scalar.RandomColor();
}
using (var imgt = new MatOfByte3(img))
{
var indexer = imgt.GetIndexer();
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
int labelValue = Labels[y, x];
indexer[y, x] = colors[labelValue].ToVec3b();
}
}
}
}
public void 自作反射光除去(Mat[] images, ref Mat DST)
{
int width = images[0].Width;
int height = images[0].Height;
MatIndexer<Vec3b>[] indexers = new MatIndexer<Vec3b>[4];
var indexer = new MatOfByte3(DST).GetIndexer();
for (int i = 0; i < 4; i++) indexers[i] = new MatOfByte3(images[i]).GetIndexer();
for (int x = 0; x < width; x++)
for (int y = 0; y < height; y++)
{
Vec3b[] colors = new Vec3b[4];
Vec3b color = indexer[y, x];
for (int i = 0; i < 4; i++) colors[i] = indexers[i][y, x];
double[] vals = { 0, 0, 0, 0 };
for (int num = 0; num < 4; num++) vals[num] = colors[num].Item0;
Array.Sort(vals);//並び替えを行う．min=vals[0]
color.Item0 = (byte)((vals[0] + vals[1] + vals[2]) / 3.0);
indexer[y, x] = color;
colors = null;
}
indexers = null;
indexer = null;
}
/// <summary>
/// Eye見て傾き検出
/// </summary>
/// <param name="srcMat"></param>
/// <param name="putMat"></param>
/// <returns></returns>
public Mat PutEllipseEyeMaskOnFace(Mat srcMat, Mat putMat)
{
var grayMat = new Mat();
Cv2.CvtColor(srcMat, grayMat, ColorConversionCodes.BGR2GRAY);
Cv2.EqualizeHist(grayMat, grayMat);
var faces = Cascade.DetectMultiScale(grayMat);
if (faces == null) return srcMat;
var polygons = new List<List<Point>>();
var faceCount = faces.Count(); // O(n)
for (int d = 0; d < faceCount; d++)
{
polygons = new List<List<Point>>();
int x1 = faces[d].X;
int y1 = faces[d].Y;
int width = faces[d].Width;
int height = faces[d].Height;
int x2 = x1 + width;
int y2 = y1 + height;
int pwidth = putMat.Width;
int pheight = putMat.Height;
int srcWidth = srcMat.Width;
int srcHeight = srcMat.Height;
polygons.Add(new List<Point>() {
new Point(x1,y1),
new Point(x2,y1),
new Point(x2,y2),
new Point(x1,y2),
});
var faceSize = new Size(width, height);
//重ねるファイルは少し拡大したほうが良いかな？
/* Mat put0 = putMat[(int)(pwidth * 0.1) ,
(int)(pwidth * 0.9),
(int)(pheight * 0.1),
(int)(pheight * 0.9)]
.Resize(new Size(width, heigh), 0, 0, InterpolationFlags.Lanczos4);
*/
Mat put0 = putMat.Resize(faceSize, 0, 0, InterpolationFlags.Lanczos4);
//真ん中編の色を適当に抽出
// 改良の余地あり（肌色領域の平均取ったり？）
MatOfByte3 mat3 = new MatOfByte3(put0); // cv::Mat_<cv::Vec3b>
var indexer = mat3.GetIndexer();
Vec3b color = indexer[(int)(put0.Width * 0.5), (int)(put0.Height * 0.5)];
//抽出した色で埋める
Mat put1 = new Mat(srcMat.Size(), MatType.CV_8UC3, new Scalar(color.Item0, color.Item1, color.Item2));
//重ねる範囲にコピー
put1[y1, y2, x1, x2] = put0;
Mat put1gray = Mat.Zeros(srcMat.Size(), MatType.CV_8UC1);
put1gray[y1, y2, x1, x2] = grayMat[y1, y2, x1, x2];
var eyes = EyeCascade.DetectMultiScale(put1gray);
/*
Debug.WriteLine(eyes.Count());
var cccc = new Point(eyes[0].X + eyes[0].Width * 0.5, eyes[0].Y + eyes[0].Height * 0.5);
put1gray.Circle(cccc,(int)(eyes[0].Width * 0.5), new Scalar(0, 255, 255));
return put1gray;*/
var eyeCount = eyes.Count();
if (eyeCount >= 2)
{
var eyePpints = new List<Point>();
var orderedEyes = eyes.OrderByDescending(x => x.Width * x.Height).ToArray();
while (true)
{
for (int i = 0; i < 2; i++)
{
eyePpints.Add(new Point(eyes[i].X + eyes[i].Width * 0.5, eyes[i].Y + eyes[i].Height * 0.5));
}
var wrapRect = Cv2.MinAreaRect(eyePpints);
if (Math.Abs(wrapRect.Angle % 180) < 20)
{
var scale = 1.0;
var angle = -wrapRect.Angle % 180;
var eyedx = (eyePpints[0].X + eyePpints[1].X) * 0.5 - wrapRect.Center.X;
var eyedy = (eyePpints[0].Y + eyePpints[1].Y) * 0.5 - wrapRect.Center.Y;
//中心はここ
var center = new Point(
(faces[d].X + faces[d].Width * 0.5) + eyedx,
(faces[d].Y + faces[d].Height * 0.5) + eyedy);
Mat matrix = Cv2.GetRotationMatrix2D(center, angle, scale);
//画像を回転させる
Cv2.WarpAffine(put1, put1, matrix, put1.Size());
var faceAvgWidth = (int)((wrapRect.Size.Width + faceSize.Width) * 0.6);
var rotateRect = new RotatedRect(center, new Size2f(faceAvgWidth, faceSize.Height * 0.9), angle);
Mat mask = Mat.Zeros(srcMat.Size(), MatType.CV_8UC3);
Cv2.Ellipse(mask, rotateRect, new Scalar(255, 255, 255), -1, LineTypes.AntiAlias);
// Cv2.FillPoly(mask, polygons, new Scalar(255, 255, 255));
Cv2.SeamlessClone(put1, srcMat, mask, center, srcMat, SeamlessCloneMethods.NormalClone);
break;
}
else
{
if (orderedEyes.Count() > 2)
{
orderedEyes = orderedEyes.Skip(1).ToArray();
}
else
{
var angle = 0;
//中心はここ
var center = new Point(faces[d].X + faces[d].Width * 0.5, faces[d].Y + faces[d].Height * 0.5);
var rotateRect = new RotatedRect(center, new Size2f(faceSize.Width * 0.8, faceSize.Height * 0.9), angle);
Mat mask = Mat.Zeros(srcMat.Size(), MatType.CV_8UC3);
Cv2.Ellipse(mask, rotateRect, new Scalar(255, 255, 255), -1, LineTypes.AntiAlias);
// Cv2.FillPoly(mask, polygons, new Scalar(255, 255, 255));
Cv2.SeamlessClone(put1, srcMat, mask, center, srcMat, SeamlessCloneMethods.NormalClone);
break;
}
}
}
}
else
{
var angle = 0;
//中心はここ
var center = new Point(faces[d].X + faces[d].Width * 0.5, faces[d].Y + faces[d].Height * 0.5);
var rotateRect = new RotatedRect(center, new Size2f(faceSize.Width * 0.8, faceSize.Height * 0.9), angle);
Mat mask = Mat.Zeros(srcMat.Size(), MatType.CV_8UC3);
Cv2.Ellipse(mask, rotateRect, new Scalar(255, 255, 255), -1, LineTypes.AntiAlias);
// Cv2.FillPoly(mask, polygons, new Scalar(255, 255, 255));
Cv2.SeamlessClone(put1, srcMat, mask, center, srcMat, SeamlessCloneMethods.NormalClone);
}
}
return srcMat;
}
/// <summary>
/// Poisson Image Editing
/// </summary>
/// <param name="srcMat">顔がある方</param>
/// <param name="putMat">重ねる顔</param>
/// <returns></returns>
public Mat PutMaskOnFace(Mat srcMat, Mat putMat)
{
var grayMat = new Mat();
Cv2.CvtColor(srcMat, grayMat, ColorConversionCodes.BGR2GRAY);
Cv2.EqualizeHist(grayMat, grayMat);
var faces = Cascade.DetectMultiScale(grayMat);
if (faces == null) return srcMat;
var binaryMat = new Mat();
int blockSize = 7;
double k = 0.15;
double R = 32;
Binarizer.Sauvola(grayMat, binaryMat, blockSize, k, R);
Cv2.BitwiseNot(binaryMat, binaryMat);
var polygons = new List<List<Point>>();
var faceCount = faces.Count(); // O(n)
for (int d = 0; d < faceCount; d++)
{
polygons = new List<List<Point>>();
int x1 = faces[d].X;
int y1 = faces[d].Y;
int width = faces[d].Width;
int heigh = faces[d].Height;
int x2 = x1 + width;
int y2 = y1 + heigh;
polygons.Add(new List<Point>() {
new Point(x1,y1),
new Point(x2,y1),
new Point(x2,y2),
new Point(x1,y2),
});
var pwidth = putMat.Width;
var pheight = putMat.Height;
//重ねるファイルは少し拡大したほうが良いかな？
/* Mat put0 = putMat[(int)(pwidth * 0.1) ,
(int)(pwidth * 0.9),
(int)(pheight * 0.1),
(int)(pheight * 0.9)]
.Resize(new Size(width, heigh), 0, 0, InterpolationFlags.Lanczos4);
*/
Mat put0 = putMat.Resize(new Size(width, heigh), 0, 0, InterpolationFlags.Lanczos4);
//真ん中編の色を適当に抽出
// 改良の余地あり（肌色領域の平均取ったり？）
MatOfByte3 mat3 = new MatOfByte3(put0); // cv::Mat_<cv::Vec3b>
var indexer = mat3.GetIndexer();
Vec3b color = indexer[(int)(put0.Width * 0.5), (int)(put0.Height * 0.5)];
//抽出した色で埋める
Mat put1 = new Mat(srcMat.Size(), MatType.CV_8UC3, new Scalar(color.Item0, color.Item1, color.Item2));
//重ねる範囲にコピー
put1[y1, y2, x1, x2] = put0;
Mat mask = Mat.Zeros(srcMat.Size(), MatType.CV_8UC3);
Cv2.FillPoly(mask, polygons, new Scalar(255, 255, 255));
//中心はここ
var center = new Point(faces[d].X + faces[d].Width * 0.5, faces[d].Y + faces[d].Height * 0.5);
Cv2.SeamlessClone(put1, srcMat, mask, center, srcMat, SeamlessCloneMethods.NormalClone);
}
return srcMat;
}
public Mat PutEllipseMaskOnFace2(Mat srcMat, Mat putMat)
{
var grayMat = new Mat();
Cv2.CvtColor(srcMat, grayMat, ColorConversionCodes.BGR2GRAY);
Cv2.EqualizeHist(grayMat, grayMat);
var faces = Cascade.DetectMultiScale(grayMat);
if (faces == null) return srcMat;
var binaryMat = new Mat();
// binaryMat = ColorExtractor.ExtractMask(srcMat,ColorConversionCodes.BGR2HSV,ColorVariation.Skin);
// return binaryMat;
int blockSize = 7;
double k = 1.5;
double R = 100;
Binarizer.Sauvola(grayMat, binaryMat, blockSize, k, R);
Cv2.BitwiseNot(binaryMat, binaryMat);
return binaryMat;
var polygons = new List<List<Point>>();
var faceCount = faces.Count(); // O(n)
for (int d = 0; d < faceCount; d++)
{
polygons = new List<List<Point>>();
int x1 = faces[d].X;
int y1 = faces[d].Y;
int width = faces[d].Width;
int height = faces[d].Height;
int x2 = x1 + width;
int y2 = y1 + height;
int pwidth = putMat.Width;
int pheight = putMat.Height;
int srcWidth = srcMat.Width;
int srcHeight = srcMat.Height;
polygons.Add(new List<Point>() {
new Point(x1,y1),
new Point(x2,y1),
new Point(x2,y2),
new Point(x1,y2),
});
// f = fixed
/* int fx1 = (int)(x1 - width * 0.01);
fx1 = fx1 > 0 ? fx1 : 0;
int fx2 = (int)(x2 + width * 0.01);
fx2 = fx2 < srcWidth ? fx2 : srcWidth;
int fy1 = (int)(y1 - height * 0.01);
fy1 = fy1 > 0 ? fy1 : 0;
int fy2 = (int)(y2 + height * 0.01);
fy2 = fy2 < srcHeight ? fy2 : srcHeight;
*/
int fx1 = (int)(x1 + width * 0.1);
int fx2 = (int)(x2 - width * 0.1);
int fy1 = (int)(y1 + height * 0.1);
int fy2 = (int)(y2 - height * 0.1);
int fwidth = x2 - x1;
int fheight = y2 - y1;
var faceSize = new Size(fwidth, fheight);
//重ねるファイルは少し拡大したほうが良いかな？
/* Mat put0 = putMat[(int)(pwidth * 0.1) ,
(int)(pwidth * 0.9),
(int)(pheight * 0.1),
(int)(pheight * 0.9)]
.Resize(new Size(width, heigh), 0, 0, InterpolationFlags.Lanczos4);
*/
Mat put0 = putMat.Resize(faceSize, 0, 0, InterpolationFlags.Lanczos4);
//真ん中編の色を適当に抽出
// 改良の余地あり（肌色領域の平均取ったり？）
MatOfByte3 mat3 = new MatOfByte3(put0); // cv::Mat_<cv::Vec3b>
var indexer = mat3.GetIndexer();
Vec3b color = indexer[(int)(put0.Width * 0.5), (int)(put0.Height * 0.5)];
//抽出した色で埋める
Mat put1 = new Mat(srcMat.Size(), MatType.CV_8UC3, new Scalar(color.Item0, color.Item1, color.Item2));
//重ねる範囲にコピー
put1[y1, y2, x1, x2] = put0;
Mat mask = Mat.Zeros(srcMat.Size(), MatType.CV_8UC3);
//中心はここ
var center = new Point(faces[d].X + faces[d].Width * 0.5, faces[d].Y + faces[d].Height * 0.5);
Mat faceAroundMat = Mat.Zeros(srcMat.Size(), MatType.CV_8UC1);
faceAroundMat[fy1, fy2, fx1, fx2] = binaryMat[fy1, fy2, fx1, fx2];
// faceAroundMat[y1, y2, x1, x2] = binaryMat[y1, y2, x1, x2];
//var countours = new
// 単純な輪郭抽出のみでは、傾きがわからない
// 元のAPIが破壊的な関数なので clone http://opencv.jp/opencv-2svn/cpp/imgproc_structural_analysis_and_shape_descriptors.html#cv-findcontours
var contours = faceAroundMat.Clone().FindContoursAsArray(RetrievalModes.List, ContourApproximationModes.ApproxNone);
//要素数が大きい輪郭だけ
var detectedContours = contours.Where(c =>
/*Cv2.ContourArea(c) > Cv2.ContourArea(polygons[0]) * 0.05 &&*/ Cv2.ContourArea(c) < Cv2.ContourArea(polygons[0]) * 0.1);
Mat conMat = Mat.Zeros(srcMat.Size(), MatType.CV_8UC1);
Cv2.DrawContours(conMat, detectedContours, -1, new Scalar(255, 255, 255));
return conMat;
var points = new List<Point>();
foreach (var dc in detectedContours)
{
points.Union(dc);
}
var detectedRotateRect = Cv2.MinAreaRect(points);
float angle =
detectedRotateRect.Angle =
Math.Abs(detectedRotateRect.Angle) > 20 ?
detectedRotateRect.Angle % 20 :
detectedRotateRect.Angle;
float scale = 1.0f;
// 回転
Mat matrix = Cv2.GetRotationMatrix2D(center, angle, scale);
Debug.WriteLine(detectedRotateRect.Angle);
//画像を回転させる
Cv2.WarpAffine(put1, put1, matrix, put1.Size());
var rotateRect = new RotatedRect(center, new Size2f(faceSize.Width, faceSize.Height), detectedRotateRect.Angle);
continue;
Cv2.Ellipse(mask, detectedRotateRect, new Scalar(255, 255, 255), -1, LineTypes.AntiAlias);
// Cv2.FillPoly(mask, polygons, new Scalar(255, 255, 255));
Cv2.SeamlessClone(put1, srcMat, mask, center, srcMat, SeamlessCloneMethods.NormalClone);
}
return srcMat;
}
public void 吉岡反射光除去処理(Mat[] images, ref Mat DST,int th_l,int th_h)
{
int width = images[0].Width;
int height = images[0].Height;
MatIndexer<Vec3b>[] indexers = new MatIndexer<Vec3b>[4];
var indexer = new MatOfByte3(DST).GetIndexer();
for (int i = 0; i < 4; i++) indexers[i] = new MatOfByte3(images[i]).GetIndexer();
for (int x = 0; x < width; x++)
for (int y = 0; y < height; y++)
{//medianX,Y SG完成
Vec3b[] colors = new Vec3b[4];
Vec3b color = indexer[y, x];
for (int i = 0; i < 4; i++) colors[i] = indexers[i][y, x];
double[] vals = { 0, 0, 0, 0 };
for (int num = 0; num < 4; num++) vals[num] = colors[num].Item0;
Array.Sort(vals);//並び替えを行う．min=vals[0]
for (int i = 1; i < 3; i++)
{
//if (vals[i] < th_l || vals[i] > th_h) vals[i] = 255;
//普通こっちでは？
//if (vals[i] < th_l) vals[i] = 0;
//if (vals[i] > th_h) vals[i] = 255;
}
color.Item0 = (byte)((vals[1] + vals[2]) / 2.0);
indexer[y, x] = color;
colors = null;
}
indexers = null;
indexer = null;
}
public void CvDct(ref Mat DST, Mat SRC, int N)
{
Mat dct, idct;
Mat dct2, dct3;
int width = SRC.Width;//N;
int height = SRC.Height;//N;
DST = SRC.Clone();
//DCT,IDCT用の行列作成(double)
dct = new Mat(height, width, MatType.CV_64FC1);
idct = new Mat(height, width, MatType.CV_64FC1);
dct2 = new Mat(height, width, MatType.CV_64FC1);
dct3 = new Mat(height, width, MatType.CV_64FC1);
var indexer_DST = new MatOfByte3(DST).GetIndexer();
var indexer_dct = new MatOfDouble3(dct).GetIndexer();
//行列dctに画像データをコピー
//double fcos;
for (int x = 0; x < width; x++)
for (int y = 0; y < height; y++)
{
Vec3d color = indexer_dct[y, x];
color.Item0= indexer_DST[y, x].Item0 / 256.0;
indexer_dct[y,x] = color;
}
//DCT…dctをコサイン変換してdct2を作成します
Cv2.Dct(dct, dct2, DctFlags.None);
//dct2をDenomで割りdct3を作成します
PerformDenom(ref dct3, dct2);
//IDCT…dct3を逆コサイン変換します
Cv2.Dct(dct3, idct, DctFlags.Inverse);
var indexer_idct = new MatOfDouble3(idct).GetIndexer();
//逆変換用画像にデータをコピー
for (int x = 0; x < width; x++)
for (int y = 0; y < height; y++)
{
Vec3b color = indexer_DST[y, x];
color.Item0= (byte)(indexer_idct[y,x].Item0 * 256.0);
indexer_DST[y,x]=color;
}
////正規化
//double min, max;
//min = 4000000000000;
//max = -4000000000000;
//double offset = 0.0;
////輝度値の最大と最小を取得
//DST.MinMaxIdx(out min, out max);
////for (int x = 0; x < width; x++)
//// for (int y = 0; y < height; y++)
//// {
//// double data = indexer_DST[y,x].Item0;
//// if (data < min) min = data;
//// if (data > max) max = data;
//// }
//for (int x = 0; x < width; x++)
// for (int y = 0; y < height; y++)
// {
// Vec3b color = indexer_DST[y, x];
// double data = indexer_DST[y, x].Item0;
// if (data < min + offset) data = min + offset;
// color.Item0 = (byte)( (((data / (max - min + offset))) * 255.0) - (((min + offset) / (max - min + offset)) * 255.0) );
// indexer_DST[y,x] = color;
// }
////DST = idct.Clone();
//行列メモリを開放します
dct.Dispose();
dct2.Dispose();
dct3.Dispose();
idct.Dispose();
indexer_dct = null;
indexer_DST = null;
indexer_idct = null;
}
public void コントラスト調整_シグモイド(ref Mat src, double 倍率)
{
int width = src.Width;
int height = src.Height;
var indexer = new MatOfByte3(src).GetIndexer();
for (int x = 0; x < width; x++)
for (int y = 0; y < height; y++)
{
Vec3b color = indexer[y, x];
color.Item0 = (byte)(255.0 / (1 + Math.Exp(-倍率 * (color.Item0 - 128) / 255)));
indexer[y, x] = color;
}
indexer = null;
}
public void infilterY(ref Mat DST,Mat SRC)
{
int width = SRC.Width;
int height = SRC.Height;
DST = SRC.Clone();
var indexer = new MatOfByte3(DST).GetIndexer();
for (int x = 0; x < width; x++)
for (int y = 0; y < height - 1; y++)
{
Vec3b color = indexer[y, x];
double val = indexer[y+1, x].Item0 - indexer[y, x].Item0;
if (val > 255) color.Item0 = 255;
else if (val < 0) color.Item0 = 0;
else color.Item0 = (byte)val;
indexer[y, x] = color;
}
indexer = null;
}
public void コントラスト調整(ref Mat src, double 倍率)
{
int width = src.Width;
int height = src.Height;
var indexer = new MatOfByte3(src).GetIndexer();
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
Vec3b color = indexer[y, x];
double val = color.Item0 * 倍率;
if (val > 255) color.Item0 = 255;
else if (val < 0) color.Item0 = 0;
else color.Item0 = (byte)val;
indexer[y, x] = color;
}
}
indexer = null;
}
public static Mat ExtractMask(Mat srcMat, ColorConversionCodes code,
int ch1Lower, int ch1Upper,
int ch2Lower, int ch2Upper,
int ch3Lower, int ch3Upper)
{
if (srcMat == null)
throw new ArgumentNullException("srcMat");
var colorMat = srcMat.CvtColor(code);
var lut = new Mat(256, 1, MatType.CV_8UC3);
var lower = new int[3] { ch1Lower, ch2Lower, ch3Lower };
var upper = new int[3] { ch1Upper, ch2Upper, ch3Upper };
// cv::Mat_<cv::Vec3b>
var mat3 = new MatOfByte3(lut);
var indexer = mat3.GetIndexer();
for (int i = 0; i < 256; i++)
{
var color = indexer[i];
byte temp;
for (int k = 0; k < 3; k++)
{
if (lower[k] <= upper[k])
{
if ((lower[k] <= i) && (i <= upper[k]))
{
temp = 255;
}
else
{
temp = 0;
}
}
else
{
if ((i <= upper[k]) || (lower[k] <= i))
{
temp = 255;
}
else
{
temp = 0;
}
}
color[k] = temp;
}
indexer[i] = color;
}
Cv2.LUT(colorMat, lut, colorMat);
var channelMat = colorMat.Split();
var maskMat = new Mat();
Cv2.BitwiseAnd(channelMat[0], channelMat[1], maskMat);
Cv2.BitwiseAnd(maskMat, channelMat[2], maskMat);
return maskMat;
}
private void OnClick実行(object sender, EventArgs e)
{
System.Diagnostics.Debug.WriteLine("OnClick実行 開始");
if (is4Image)
{
int width = 入力画像[0].Width;
int height = 入力画像[0].Height;
SGx = new OpenCvSharp.Mat(height,width, MatType.CV_8UC1);
SGy = new OpenCvSharp.Mat(height, width, MatType.CV_8UC1);
for (int num = 0; num < 4; num++)
{
Gx[num] = 入力画像[num].Clone();
Gy[num] = 入力画像[num].Clone();
}
for (int num = 0; num < 4; num++)
{//infilterX,Y
mCV.infilterX(ref Gx[num], 入力画像[num]);
mCV.infilterY(ref Gy[num], 入力画像[num]);
}
mCV.Median(Gx, ref SGx);
mCV.Median(Gy, ref SGy);
//Gxxを作る．とりあえず外周1ピクセルやらない方向で．
Gxx = new OpenCvSharp.Mat(height, width, MatType.CV_8UC1);
Gyy = new OpenCvSharp.Mat(height, width, MatType.CV_8UC1);
mCV.infilterX(ref Gxx, SGx);
mCV.infilterY(ref Gyy, SGy);
//SP作成（仮の出力画像）
Mat SP = new OpenCvSharp.Mat(height,width, MatType.CV_8UC1);
var indexer_sp = new MatOfByte3(SP).GetIndexer();
var indexer_Gxx= new MatOfByte3(Gxx).GetIndexer();
var indexer_Gyy = new MatOfByte3(Gyy).GetIndexer();
for (int x = 0; x < width; x++)
for (int y = 0; y < height; y++)
{
Vec3b color = indexer_sp[y, x];
double val = indexer_Gxx[y, x].Item0+ indexer_Gyy[y, x].Item0;
if (val > 255) color.Item0 = 255;
else if (val < 0) color.Item0 = 0;
else color.Item0 = (byte)val;
indexer_sp[y, x] = color;
}
indexer_sp =null;
indexer_Gxx =null;
indexer_Gyy = null;
Mat DCT_dst = new OpenCvSharp.Mat(height, width, MatType.CV_8UC1);
mCV.CvDct(ref DCT_dst,SP, 1024);//第3引数使われてない件
//DCT_dst = SP.Clone();
//mCV.吉岡反射光除去処理(入力画像, ref DCT_dst,int.Parse(textBox_Gaus.Text),int.Parse(textBox_Bright.Text));
出力画像=DCT_dst.Clone();
}
else System.Diagnostics.Debug.WriteLine("no 4 images");
System.Diagnostics.Debug.WriteLine("OnClick実行 終了");
}
