public CvContours GetNearPointContour(Point pt, CenterDrawMode centerMode)
{
CvContours resultContours = new CvContours();
int nearId = 0;
double minLen = double.MaxValue;
for (int nId = 0; nId < m_contours.Count; nId++)
{
Point centerPoint = m_contours[nId].BoundingCenter;
switch (centerMode)
{
case CenterDrawMode.PixelWeightCenter:
centerPoint = m_contours[nId].WeightCenter;
break;
case CenterDrawMode.HistogramCenter:
centerPoint = m_contours[nId].HistogramCenter;
break;
}
double len = (centerPoint.X - pt.X) * (centerPoint.X - pt.X) +
(centerPoint.Y - pt.Y) * (centerPoint.Y - pt.Y);
if (len < minLen)
{
minLen = len;
nearId = nId;
}
}
resultContours.m_contours.Add(m_contours[nearId].Clone());
return(resultContours);
}
/// <summary>
/// Создаёт контур из внешних точек при помощи афинной гистограммы
/// </summary>
/// <param name="centerMode">Выбор центра внешнего контура</param>
/// <param name="histogramScale">Число баров гистограммы 3*histogramScale* (длина стороны матрицы)</param>
/// <param name="radiusScale">Скалированный радиус от центра</param>
/// <returns></returns>
public CvContourInfo ToAraundContour(CenterDrawMode centerMode = CenterDrawMode.BoundingRectCenter, int histogramScale = 1, double radiusScale = 1, MovingPredictType movingType = MovingPredictType.None, int movingRange = 1)
{
CvContourInfo araundContour = new CvContourInfo();
Point center = this.BoundingCenter;
switch (centerMode)
{
case CenterDrawMode.PixelWeightCenter: center = this.WeightCenter; break;
case CenterDrawMode.HistogramCenter:
UpdateXYHistogram();
center = this.HistogramCenter;
break;
}
araundContour.m_points = AraundPoints(center, m_points, histogramScale, radiusScale, movingType, movingRange);
araundContour.Id = this.Id;
araundContour.ParentId = this.ParentId;
araundContour.MainColor = new MCvScalar(this.MainColor.V0, this.MainColor.V1, this.MainColor.V2);
araundContour.PerimeterColor = new MCvScalar(this.PerimeterColor.V0, this.PerimeterColor.V1, this.PerimeterColor.V2);
araundContour.Area = this.Area;
araundContour.Perimeter = this.Perimeter;
araundContour.BoundingRect = new Rectangle(this.BoundingRect.X, this.BoundingRect.Y, this.BoundingRect.Width, this.BoundingRect.Height);
araundContour.BoundingCenter = new Point(this.BoundingCenter.X, this.BoundingCenter.Y);
araundContour.WeightCenter = new Point(this.WeightCenter.X, this.WeightCenter.Y);
araundContour.HistogramCenter = new Point(this.HistogramCenter.X, this.HistogramCenter.Y);
return(araundContour);
}
public override bool Do()
{
try
{
m_contours.Clear();
FilterDrawMode DrawOn = (FilterDrawMode)EnumPropertys["DrawOn"].Value;
CenterDrawMode CenterMode = (CenterDrawMode)EnumPropertys["CenterMode"].Value;
FilterDrawMode BoundingRect = (FilterDrawMode)EnumPropertys["BoundingRect"].Value;
bool bShowBoundingRect = BoundingRect == FilterDrawMode.Show;
FillDrawModeEnum FillMode = (FillDrawModeEnum)EnumPropertys["FillMode"].Value;
bool bFill = FillMode != FillDrawModeEnum.None;
MovingPredictType movingType = (MovingPredictType)EnumPropertys["MovingType"].Value;
foreach (var src in Sources)
{
IContourFilter searchFilter = src as IContourFilter;
if (searchFilter == null)
{
continue;
}
var outData = src.GetOut();
var contourSrcs = searchFilter.GetResultContours();
for (int dataID = 0; dataID < outData.Count; dataID++)
{
var dst = outData[dataID].Image.Clone();
var aroundContours = contourSrcs[dataID].GetAroundContours(CenterMode,
IntPropertys["HScale"].Value,
FloatPropertys["RScale"].Value,
movingType, IntPropertys["MovingRange"].Value
);
m_contours.Add(aroundContours);
if (DrawOn == FilterDrawMode.Show)
{
if (FillMode == FillDrawModeEnum.SourceMeanColor)
{
aroundContours.UpdateMainColorAsMeanOfMask(dst);
}
aroundContours.Draw(dst, bFill, bShowBoundingRect, CenterMode);
}
this.m_out.Add(new DataSrc(dst, outData[dataID].Info, false));
}
}
}
catch (CvException ex)
{
return(false);
}
return(true);
}
public CvContours GetAroundContours(CenterDrawMode centerMode, int histogramScale = 1, double radiusScale = 1, MovingPredictType movingType = MovingPredictType.None, int movingRange = 1)
{
CvContours resultContour = new CvContours();
foreach (var contour in m_contours)
{
resultContour.m_contours.Add(contour.ToAraundContour(centerMode, histogramScale, radiusScale, movingType, movingRange));
}
return(resultContour);
}
public override bool Do()
{
try
{
m_contours.Clear();
FilterDrawMode DrawOn = (FilterDrawMode)EnumPropertys["DrawOn"].Value;
FilterDrawMode BoundingRect = (FilterDrawMode)EnumPropertys["BoundingRect"].Value;
bool bShowBoundingRect = BoundingRect == FilterDrawMode.Show;
CenterDrawMode centerDrawMode = (CenterDrawMode)EnumPropertys["CenterDrawMode"].Value;
FillDrawModeEnum FillMode = (FillDrawModeEnum)EnumPropertys["FillMode"].Value;
bool bFill = FillMode != FillDrawModeEnum.None;
FilterDrawMode Histogram = (FilterDrawMode)EnumPropertys["Histogram"].Value;
bool bHistogram = Histogram == FilterDrawMode.Show;
SourceDrawModeEnum SourceMode = (SourceDrawModeEnum)EnumPropertys["SourceMode"].Value;
BaseFilter drawSourceFilter = Graph.GetFilter(EnumPropertys["DrawSource"].Value);
List <DataSrc> drawDataSrcs = null;
int drawDataCnt = 0;
if (drawSourceFilter != null)
{
drawDataSrcs = drawSourceFilter.GetOut();
drawDataCnt = drawDataSrcs.Count;
}
foreach (var src in Sources)
{
var outData = src.GetOut();
int dataID = 0; // перебор картинок в сорсе
int exsourceID = 0; // перебор картинок стороннего источника при DrawSourceMode
Mat currentImg = null;
while ((dataID < outData.Count) || ((SourceMode == SourceDrawModeEnum.DrawSource) && (exsourceID < drawDataCnt)))
{
string dataInfo = "unknow";
if (dataID < outData.Count)
{
dataInfo = outData[dataID].Info;
currentImg = outData[dataID++].Image;
}
if (currentImg == null)
{
break;
}
Mat dst = null;
switch (SourceMode)
{
case SourceDrawModeEnum.Self: dst = currentImg.Clone(); break;
case SourceDrawModeEnum.None: dst = new Mat(currentImg.Size, currentImg.Depth, currentImg.NumberOfChannels); break;
case SourceDrawModeEnum.DrawSource:
if (exsourceID < drawDataCnt)
{
dataInfo = drawDataSrcs[exsourceID].Info;
dst = drawDataSrcs[exsourceID++].Image.Clone();
}
else
{
dst = new Mat(currentImg.Size, currentImg.Depth, currentImg.NumberOfChannels);
}
break;
}
CvContours contours = new CvContours();
contours.Update(currentImg);
if (FillMode == FillDrawModeEnum.SourceMeanColor)
{
contours.UpdateMainColorAsMeanOfMask(dst);
}
if (centerDrawMode == CenterDrawMode.HistogramCenter)
{
contours.UpdateXYHistogram();
}
if (DrawOn == FilterDrawMode.Show)
{
contours.Draw(dst, bFill, bShowBoundingRect, centerDrawMode, IntPropertys["Thickness"].Value, bHistogram);
}
this.m_contours.Add(contours);
this.m_out.Add(new DataSrc(dst, dataInfo, false));
}
}
}
catch (CvException ex)
{
return(false);
}
return(true);
}
public override bool Do()
{
try
{
m_contours.Clear();
FilterDrawMode DrawOn = (FilterDrawMode)EnumPropertys["DrawOn"].Value;
FilterDrawMode BoundingRect = (FilterDrawMode)EnumPropertys["BoundingRect"].Value;
bool bShowBoundingRect = BoundingRect == FilterDrawMode.Show;
CenterDrawMode centerDrawMode = (CenterDrawMode)EnumPropertys["CenterDrawMode"].Value;
FillDrawModeEnum FillMode = (FillDrawModeEnum)EnumPropertys["FillMode"].Value;
bool bFill = FillMode != FillDrawModeEnum.None;
FilterDrawMode Histogram = (FilterDrawMode)EnumPropertys["Histogram"].Value;
bool bHistogram = Histogram == FilterDrawMode.Show;
foreach (var src in Sources)
{
IContourFilter searchFilter = src as IContourFilter;
if (searchFilter == null)
{
continue;
}
var outData = src.GetOut();
var contourSrcs = searchFilter.GetResultContours();
for (int dataID = 0; dataID < outData.Count; dataID++)
{
var dst = outData[dataID].Image.Clone();
string dataInfo = outData[dataID].Info;
if (dataID >= contourSrcs.Count)
{
this.m_out.Add(new DataSrc(dst, dataInfo, false));
continue;
}
var sortAreaContour = contourSrcs[dataID].GetPerimeterInRange(FloatPropertys["MinArea"].Value, FloatPropertys["MaxArea"].Value);
var sortPerimeterContour = sortAreaContour.GetPerimeterInRange(FloatPropertys["MinPerimeter"].Value, FloatPropertys["MaxPerimeter"].Value);
var sortBoundingRectContour = sortPerimeterContour.GetBoundingRectInRange(IntPropertys["MinWidth"].Value, IntPropertys["MaxWidth"].Value,
IntPropertys["MinHeight"].Value, IntPropertys["MaxHeight"].Value);
if (FillMode == FillDrawModeEnum.SourceMeanColor)
{
sortBoundingRectContour.UpdateMainColorAsMeanOfMask(dst);
}
m_contours.Add(sortBoundingRectContour);
if (centerDrawMode == CenterDrawMode.HistogramCenter)
{
sortBoundingRectContour.UpdateXYHistogram();
}
if (DrawOn == FilterDrawMode.Show)
{
sortBoundingRectContour.Draw(dst, bFill, bShowBoundingRect, centerDrawMode, IntPropertys["Thickness"].Value, bHistogram);
}
this.m_out.Add(new DataSrc(dst, dataInfo, false));
}
}
}
catch (CvException ex)
{
return(false);
}
return(true);
}
// По идее ещё нужен алгоритм кластеризации
//public CvContours[] GetClasters()
/// <summary>
/// Сливает все конутра коллекции во внешний контур с единым центром
/// </summary>
/// <param name="centerMode"></param>
/// <param name="histogramScale"></param>
/// <param name="radiusScale"></param>
/// <returns></returns>
public CvContours GetConcatenateAroundContour(CenterDrawMode centerMode = CenterDrawMode.BoundingRectCenter, int histogramScale = 1, double radiusScale = 1)
{
CvContours resultContour = new CvContours();
if (m_contours.Count == 0)
{
return(resultContour);
}
int totalPoints = 0;
foreach (var contour in m_contours)
{
totalPoints += contour.PointsCnt;
}
if (totalPoints == 0)
{
return(resultContour);
}
double xx = 0;
double yy = 0;
int shift = 0;
Point[] points = new Point[totalPoints];
foreach (var contour in m_contours)
{
contour.CopyPointsTo(points, shift);
shift += contour.PointsCnt;
switch (centerMode)
{
case CenterDrawMode.BoundingRectCenter:
xx += contour.BoundingCenter.X;
yy += contour.BoundingCenter.Y;
break;
case CenterDrawMode.PixelWeightCenter:
xx += contour.WeightCenter.X;
yy += contour.WeightCenter.Y;
break;
case CenterDrawMode.HistogramCenter:
contour.UpdateXYHistogram();
xx += contour.HistogramCenter.X;
yy += contour.HistogramCenter.Y;
break;
}
}
Point commonCenterPoint = new Point((int)(xx / m_contours.Count), (int)(yy / m_contours.Count));
var aroundPoints = CvContourInfo.AraundPoints(commonCenterPoint, points, histogramScale, radiusScale);
CvContourInfo contourInfo = new CvContourInfo(0, -1, aroundPoints);
resultContour.m_contours.Add(contourInfo);
return(resultContour);
}
public void Draw(Mat src, bool bFill = false, bool bShowBoundingRect = false, CenterDrawMode centerDrawMode = CenterDrawMode.BoundingRectCenter, int thickness = 3, bool bHistogram = false)
{
using (VectorOfPoint vp = new VectorOfPoint(m_points))
using (VectorOfVectorOfPoint vvp = new VectorOfVectorOfPoint(vp))
{
if (bFill)
{
CvInvoke.FillPoly(src, vvp, MainColor);
}
if (thickness > 0)
{
CvInvoke.DrawContours(src, vvp, 0, PerimeterColor, thickness, LineType.EightConnected);
}
if (bShowBoundingRect && ((thickness > 0)))
{
Point usedCenter = BoundingCenter;
switch (centerDrawMode)
{
case CenterDrawMode.BoundingRectCenter: usedCenter = BoundingCenter; break;
case CenterDrawMode.PixelWeightCenter: usedCenter = WeightCenter; break;
case CenterDrawMode.HistogramCenter: usedCenter = HistogramCenter; break;
}
CvInvoke.Rectangle(src, this.BoundingRect, PerimeterColor, thickness);
int szX = BoundingRect.Width / 8;
int szY = BoundingRect.Height / 8;
Point linex1 = new Point(usedCenter.X - szX, usedCenter.Y);
Point linex2 = new Point(usedCenter.X + szX, usedCenter.Y);
Point liney1 = new Point(usedCenter.X, usedCenter.Y - szY);
Point liney2 = new Point(usedCenter.X, usedCenter.Y + szY);
CvInvoke.Line(src, linex1, linex2, PerimeterColor, thickness);
CvInvoke.Line(src, liney1, liney2, PerimeterColor, thickness);
}
if (bHistogram)
{
UpdateXYHistogram();
for (int xx = 0; xx < XHistogram.Length; xx++)
{
Point ln1 = new Point(BoundingRect.X + xx, BoundingRect.Y + BoundingRect.Height);
Point ln2 = new Point(BoundingRect.X + xx, BoundingRect.Y + BoundingRect.Height + (int)XHistogram[xx]);
CvInvoke.Line(src, ln1, ln2, PerimeterColor, thickness);
}
for (int yy = 0; yy < YHistogram.Length; yy++)
{
Point ln1 = new Point(BoundingRect.X + BoundingRect.Width, BoundingRect.Y + yy);
Point ln2 = new Point(BoundingRect.X + BoundingRect.Width + (int)YHistogram[yy], BoundingRect.Y + yy);
CvInvoke.Line(src, ln1, ln2, PerimeterColor, thickness);
}
}
}
}
public void Draw(Mat src, bool bFill = false, bool bShowBoundingRect = false, CenterDrawMode centerDrawMode = CenterDrawMode.BoundingRectCenter, int thickness = 3, bool bHistogram = false)
{
if (!bFill)
{
foreach (var contour in m_contours)
{
contour.Draw(src, bFill, bShowBoundingRect, centerDrawMode, thickness, bHistogram);
}
return;
}
// Нужно рисовать исходя из иерархии
bool[] WriteAlready = new bool[GetMaxId() + 1];
foreach (var contour in m_contours)
{
FillDrawRecurrent(src, WriteAlready, contour.Id, thickness, bHistogram);
}
}
