using System;
|
using System.Collections.Generic;
|
using System.Diagnostics;
|
using System.IO;
|
using System.Linq;
|
using System.Text;
|
using System.Threading.Tasks;
|
using System.Xml;
|
using Emgu.CV;
|
using Emgu.CV.CvEnum;
|
using Emgu.CV.ML;
|
using Emgu.CV.Structure;
|
|
namespace RichCreator.Editor.Utils
|
{
|
public class HOGDetector
|
{
|
public HOGDetector(System.Drawing.Size winSize,
|
System.Drawing.Size blockSize,
|
System.Drawing.Size strideSize,
|
System.Drawing.Size cellSize,
|
Int32 channel,
|
string xmlFile)
|
{
|
this.WinSize = winSize;
|
this.BlockSize = blockSize;
|
this.StrideSize = strideSize;
|
this.CellSize = cellSize;
|
this.Channel = channel;
|
this.XmlFile = xmlFile;
|
|
Initizlize();
|
|
}
|
|
|
public System.Drawing.Size WinSize { get; set; }
|
|
public System.Drawing.Size BlockSize { get; set; }
|
|
public System.Drawing.Size StrideSize { get; set; }
|
|
public System.Drawing.Size CellSize { get; set; }
|
|
public Int32 Channel { get; set; }
|
|
public string XmlFile { get; set; }
|
|
|
private HOGDescriptor hog;
|
|
|
private float rhoValue = 0;
|
private string alphaValue = "";
|
private int sv_count = 0;
|
private float[] alphaArr = null;
|
private Matrix<float> svmMat = null;
|
|
private void Initizlize()
|
{
|
hog = new HOGDescriptor(this.WinSize, this.BlockSize, this.StrideSize, this.CellSize, this.Channel);
|
float[] svmDetector = GetSVMDetector(this.XmlFile);
|
try
|
{
|
hog.SetSVMDetector(svmDetector);
|
}
|
catch (Exception e)
|
{
|
Trace.Write(e.Message);
|
}
|
|
}
|
|
/// <summary>
|
/// 识别
|
/// </summary>
|
/// <param name="targetImage"></param>
|
/// <param name="svmDetector"></param>
|
/// <returns></returns>
|
public ZTRect[] DetectorImage(string targetImage)
|
{
|
ZTRect[] regions;
|
Mat image = new Mat(targetImage, ImreadModes.Color);
|
MCvObjectDetection[] results = hog.DetectMultiScale(image);
|
if (results.Length > 0)
|
{
|
regions = new ZTRect[results.Length];
|
for (int i = 0; i < results.Length; i++)
|
{
|
regions[i] = new ZTRect(results[i].Rect, results[i].Score, results[i].ClassId);
|
}
|
return regions;
|
}
|
else
|
{
|
return new ZTRect[0];
|
}
|
}
|
|
public static ZTRect[] DetectorPeople(string targetImage)
|
{
|
Mat image = new Mat(targetImage, ImreadModes.Color);
|
|
using (HOGDescriptor hog = new HOGDescriptor())
|
{
|
float[] arr = HOGDescriptor.GetDefaultPeopleDetector();
|
hog.SetSVMDetector(arr);
|
|
MCvObjectDetection[] results = hog.DetectMultiScale(image);
|
return GetRects(results);
|
}
|
}
|
|
private static ZTRect[] GetRects(MCvObjectDetection[] results)
|
{
|
if (results.Length > 0)
|
{
|
|
ZTRect[] regions = new ZTRect[results.Length];
|
for (int i = 0; i < results.Length; i++)
|
{
|
regions[i] = new ZTRect(results[i].Rect, results[i].Score, results[i].ClassId);
|
}
|
return regions;
|
}
|
else
|
{
|
return new ZTRect[0];
|
}
|
}
|
|
|
/// <summary>
|
/// 得到SVM Detector
|
/// </summary>
|
/// <returns></returns>
|
private float[] GetSVMDetector(string xmlFile)
|
{
|
#region 读取已经训练好的XML
|
SVM svm = new SVM();
|
FileStorage fsr = new FileStorage(xmlFile, FileStorage.Mode.Read);
|
svm.Read(fsr.GetFirstTopLevelNode());
|
#endregion
|
|
XmlDocument xml = new XmlDocument();
|
xml.Load(xmlFile);
|
get_rho(xml.DocumentElement);
|
getAlpha_str(xml.DocumentElement);
|
getSv_count(xml.DocumentElement);
|
getAlpha();
|
|
int supportVectors = svm.GetSupportVectors().Height;
|
int DescriptorDim = svm.GetSupportVectors().Width;
|
|
svmMat = new Matrix<float>(supportVectors, DescriptorDim);
|
get_supportVector(xml.DocumentElement);
|
|
Matrix<float> alphaMat = new Matrix<float>(1, supportVectors);
|
for (int i = 0; i < alphaArr.Length; i++)
|
{
|
alphaMat[0, i] = alphaArr[i];
|
}
|
|
Matrix<float> resultMat = new Matrix<float>(1, DescriptorDim);
|
resultMat = -1 * alphaMat * svmMat;
|
|
float[] mydetector = new float[DescriptorDim + 1];
|
for (int i = 0; i < DescriptorDim; i++)
|
{
|
mydetector[i] = resultMat[0, i];
|
}
|
mydetector[DescriptorDim] = rhoValue;
|
|
return mydetector;
|
}
|
|
|
#region 读取xml
|
public void get_rho(XmlNode nodes)
|
{
|
if (nodes.HasChildNodes)
|
{
|
foreach (XmlNode node in nodes.ChildNodes)
|
{
|
if (nodes.Name == "rho")
|
{
|
rhoValue = float.Parse(nodes.InnerText);
|
return;
|
}
|
get_rho(node);
|
}
|
}
|
}
|
|
public void getAlpha_str(XmlNode nodes)
|
{
|
if (nodes.HasChildNodes)
|
{
|
foreach (XmlNode node in nodes.ChildNodes)
|
{
|
if (nodes.Name == "alpha")
|
{
|
alphaValue = nodes.InnerText;
|
return;
|
}
|
getAlpha_str(node);
|
}
|
}
|
}
|
|
public void getSv_count(XmlNode nodes)
|
{
|
if (nodes.HasChildNodes)
|
{
|
foreach (XmlNode node in nodes.ChildNodes)
|
{
|
if (nodes.Name == "sv_count")
|
{
|
sv_count = int.Parse(nodes.InnerText);
|
return;
|
}
|
getSv_count(node);
|
}
|
}
|
}
|
|
public void getAlpha()
|
{
|
byte[] array = Encoding.ASCII.GetBytes(alphaValue);
|
MemoryStream stream = new MemoryStream(array); //convert stream 2 string
|
StreamReader sr = new StreamReader(stream);
|
alphaArr = new float[sv_count];
|
sr.ReadLine();
|
int i = 0;
|
while (true)
|
{
|
|
string tmp = sr.ReadLine();
|
if (tmp == "")
|
continue;
|
|
string[] tmp2 = tmp.Split(' ');
|
foreach (string ele in tmp2)
|
{
|
if (ele != "")
|
{
|
alphaArr[i] = float.Parse(ele);
|
i++;
|
}
|
}
|
|
if (i == sv_count)
|
break;
|
}
|
}
|
|
public void get_supportVector(XmlNode nodes)
|
{
|
if (nodes.HasChildNodes)
|
{
|
foreach (XmlNode node in nodes.ChildNodes)
|
{
|
if (nodes.Name == "support_vectors")
|
{
|
for (int i = 0; i < node.ChildNodes.Count; i++)
|
{
|
string strValue = node.ChildNodes[i].InnerText;
|
string[] tempStrArr = strValue.Replace("\r\n", "")
|
.Replace(" ", " ").Replace(" ", " ").Replace(" ", " ")
|
.Replace(" ", " ").Replace(" ", " ").Replace(" ", " ")
|
.Replace(" ", " ").Split(' ');
|
int z = 0;
|
for (int j = 0; j < tempStrArr.Length; j++)
|
{
|
if (tempStrArr[j] != "")
|
{
|
svmMat[i, z] = float.Parse(tempStrArr[j]);
|
z++;
|
}
|
}
|
}
|
return;
|
}
|
get_supportVector(node);
|
}
|
}
|
}
|
#endregion
|
}
|
}
|
