public void DetectConnectedObjects()
{
DenseMatrix dmDataBinary = dmSourceData.Copy();
dmDataBinary.MapInplace(dVal => (dVal >= slicingThresholdingValue) ? (1.0d) : (0.0d));
Image <Gray, Byte> imgDataBinary = ImageProcessing.grayscaleImageFromDenseMatrixWithFixedValuesBounds(dmDataBinary, 0.0d, 1.0d);
previewImage = imgDataBinary.CopyBlank().Convert <Bgr, Byte>();
// VectorOfVectorOfPoint contoursDetected = new VectorOfVectorOfPoint();
List <Contour <Point> > edgeContoursList = imgDataBinary.DetectContours();
#region // EmguCV 3.0
//CvInvoke.FindContours(imgDataBinary, contoursDetected, null, RetrType.List,
// ChainApproxMethod.ChainApproxSimple);
//imgDataBinary.FindContours(Emgu.CV.CvEnum.CHAIN_APPROX_METHOD.CV_CHAIN_APPROX_SIMPLE,
// Emgu.CV.CvEnum.RETR_TYPE.CV_RETR_LIST);
//edgeContoursList = new List<VectorOfPoint>();
//int count = contoursDetected.Size;
//for (int i = 0; i < count; i++)
//{
// Color currentColor = colorGen.GetNext();
// var currentColorBgr = new Bgr(currentColor);
// using (VectorOfPoint currContour = contoursDetected[i])
// {
// edgeContoursList.Add(currContour);
// previewImage.Draw(currContour.ToArray(), currentColorBgr, -1);
// }
//}
#endregion // EmguCV 3.0
RandomPastelColorGenerator colorGen = new RandomPastelColorGenerator();
foreach (Contour <Point> currContour in edgeContoursList)
{
Color currentColor = colorGen.GetNext();
Bgr currentColorBgr = new Bgr(currentColor);
previewImage.Draw(currContour, currentColorBgr, -1);
}
}
private static bool GetNewColor(ushort vehicleID, ref Color __result, ColorConfigurationXml itemData)
{
float multiplier;
switch (itemData.ColoringMode)
{
case ColoringMode.PASTEL_FULL_VIVID:
multiplier = 1.3f;
goto CASE_ORIG;
case ColoringMode.PASTEL_HIGHER_SATURATION:
multiplier = 1.1f;
goto CASE_ORIG;
case ColoringMode.PASTEL_ORIG:
multiplier = 1f;
CASE_ORIG:
__result = new RandomPastelColorGenerator(vehicleID, multiplier, itemData.PastelConfig).GetNext();
LogUtils.DoLog($"GETTING PASTEL COLOR: {__result}");
return(false);
case ColoringMode.LIST:
if (itemData.ColorList.Count == 0)
{
LogUtils.DoLog($"NO COLOR AVAILABLE!");
return(true);
}
Randomizer randomizer = new Randomizer(vehicleID);
__result = itemData.ColorList[randomizer.Int32((uint)itemData.ColorList.Count)];
LogUtils.DoLog($"GETTING LIST COLOR: {__result}");
return(false);
default:
LogUtils.DoLog($"GETTING DEFAULT COLOR!");
return(true);
}
}
public void Clusterize()
{
ArithmeticsOnImages aoi = new ArithmeticsOnImages();
aoi.dmY = dmDensityMesh;
aoi.ExprString = "grad5p(Y)";
aoi.RPNeval(true);
List <DenseMatrix> lDMGradField = aoi.lDMRes;
DenseMatrix dmMask = dmDensityMesh.Copy();
dmMask.MapIndexedInplace((r, c, dVal) =>
{
// r = y - perc5
// c = x - median
Point currPt = new Point(c, r);
return((conditionOnPoints(currPt)) ? (1.0d) : (0.0d));
//if (r > c) return 0.0d;
//else return 1.0d;
});
Image <Gray, Byte> imgMask = ImageProcessing.grayscaleImageFromDenseMatrixWithFixedValuesBounds(dmMask, 0.0d, 1.0d);
// imgMask = imgMask.Flip(FlipType.Vertical);
imgMask = imgMask.Flip(FLIP.VERTICAL);
// отфильтровать малые значения - ?
// выделить классы
List <ConnectedObjectsAtASlice> lSlicesData = new List <ConnectedObjectsAtASlice>();
double dthresholdingMaxValue = dmDensityMesh.Values.Max();
//double dthresholdingMinValue = dmSmoothed.Values.Min();
double dthresholdingMinValue = 0.0d;
double dthresholdingDiscrete = (dthresholdingMaxValue - dthresholdingMinValue) / 30.0d;
for (double dThresholding = dthresholdingMaxValue; dThresholding > dthresholdingMinValue - dthresholdingDiscrete; dThresholding -= dthresholdingDiscrete)
{
ConnectedObjectsAtASlice corrSliceObj = new ConnectedObjectsAtASlice(dmDensityMesh, dmDensityMeshXcoord,
dmDensityMeshYcoord, dThresholding);
corrSliceObj.DetectConnectedObjects();
//ServiceTools.ShowPicture(corrSliceObj.previewImage, "thresholding value = " + dThresholding.ToString("e"));
lSlicesData.Add(corrSliceObj);
}
ConnectedObjectsAtASlice prevSlice = lSlicesData[0];
foundClassesContours.AddRange(prevSlice.edgeContoursList);
foreach (ConnectedObjectsAtASlice currSlice in lSlicesData)
{
if (lSlicesData.IndexOf(currSlice) == 0)
{
continue; // самый верхний пропускаем
}
//List<Tuple<Contour<Point>, Contour<Point>>> currSliceCoveringContours =
// new List<Tuple<Contour<Point>, Contour<Point>>>();
List <Tuple <Contour <Point>, Contour <Point> > > currSliceCoveringContours =
new List <Tuple <Contour <Point>, Contour <Point> > >();
//item1 - внутренний, из предыдущего слайса
//item2 - внешний, из текущего слайса
foreach (Contour <Point> caughtCont in foundClassesContours)
{
Contour <Point> coveringCaughtCont = currSlice.FindContourContainingSample(caughtCont);
currSliceCoveringContours.Add(new Tuple <Contour <Point>, Contour <Point> >(caughtCont,
coveringCaughtCont));
}
// добавим контуры, которые только что появились и раньше не были видны на срезах
// но только если количество допустимых клатеров еще позволяет
// Иначе - будем ждать, когда они вольются в в какой-нибудь из вновь расширившихся контуров
foreach (Contour <Point> newContour in currSlice.edgeContoursList)
{
if ((currSliceCoveringContours.Find(tpl => (tpl.Item2 == newContour)) == null) && (currSliceCoveringContours.Count() < maxClustersCount))
{
currSliceCoveringContours.Add(new Tuple <Contour <Point>, Contour <Point> >(newContour, newContour));
}
}
// что делать, если какой-нибудь новый контур покрывает больше одного предыдущего
List <IGrouping <Contour <Point>, Tuple <Contour <Point>, Contour <Point> > > > groups =
new List <IGrouping <Contour <Point>, Tuple <Contour <Point>, Contour <Point> > > >
(currSliceCoveringContours.GroupBy(tpl => tpl.Item2));
if (groups.Count(grp => (grp.Count() > 1)) > 0)
{
// есть контуры текущего среза, которые содержат более одного контура предыдущего среза
foreach (IGrouping <Contour <Point>, Tuple <Contour <Point>, Contour <Point> > > currGroup in groups)
{
if (currGroup.Count() == 1)
{
Tuple <Contour <Point>, Contour <Point> > contourTuple = currGroup.First();
foundClassesContours.Remove(contourTuple.Item1);
foundClassesContours.Add(contourTuple.Item2);
}
else
{
// currGroup - группа кортежей контуров, где
// item1 - внутренний, из предыдущего слайса
// item2 - внешний, из текущего слайса
// надо точки, которые лежат вне контуров предыдущего слайса отнести к "своим" контурам
// попробуем по направлению градиента - относить точку к тому контуру, на который укажет вектор градиента
Contour <Point> currCoveringContour = currGroup.Key; // item2 - внешний, из текущего слайса - см.строку группировки
Rectangle currCoveringContourBoundingRectangle = currCoveringContour.BoundingRectangle;
Image <Gray, byte> tmpImg1 =
new Image <Gray, byte>(new Size(currCoveringContourBoundingRectangle.Right,
currCoveringContourBoundingRectangle.Bottom));
tmpImg1.Draw(currCoveringContour, white, -1);
foreach (Tuple <Contour <Point>, Contour <Point> > tpl in currGroup)
{
Contour <Point> excludingCntr = tpl.Item1;
Image <Gray, byte> tmpExcl = tmpImg1.CopyBlank();
tmpExcl.Draw(excludingCntr, white, -1);
tmpImg1 = tmpImg1 - tmpExcl;
}
// в картинке tmpImg1 закрашенными остались только точки, которые надо классифицировать
List <Point> lPointsToClassify = new List <Point>();
for (int x = 0; x < tmpImg1.Width; x++)
{
for (int y = 0; y < tmpImg1.Height; y++)
{
Point currPt = new Point(x, y);
if (tmpImg1[currPt].Equals(white))
{
lPointsToClassify.Add(currPt);
}
}
}
List <List <Point> > llArraysOfPointsAdding = new List <List <Point> >();
foreach (Tuple <Contour <Point>, Contour <Point> > tpl in currGroup)
{
llArraysOfPointsAdding.Add(new List <Point>());
}
List <Contour <Point> > lContoursOfTheCurrGroup =
(new List <Tuple <Contour <Point>, Contour <Point> > >(currGroup.ToArray())).ConvertAll(
tpl => tpl.Item1);
List <PointD> lPtdMassCenters = lContoursOfTheCurrGroup.ConvertAll(cntr => cntr.MassCenter());
Contour <Point> themassCentersPolygon = new Contour <Point>(new MemStorage());
themassCentersPolygon.PushMulti(lPtdMassCenters.ConvertAll <Point>(ptd => ptd.Point()).ToArray(),
BACK_OR_FRONT.BACK);
//themassCentersPolygon.Push(lPtdMassCenters.ConvertAll<Point>(ptd => ptd.Point()).ToArray());
Image <Gray, byte> tmpImg = imgMask.CopyBlank();
tmpImg.Draw(themassCentersPolygon, white, -1);
themassCentersPolygon = tmpImg.DetectContours()[0];
foreach (Point currPtToClassify in lPointsToClassify)
{
int cntrToAddPointTo = AttachPointToOneOfConcurrentContours(
lContoursOfTheCurrGroup,
lPtdMassCenters,
themassCentersPolygon,
currPtToClassify,
lDMGradField);
if (cntrToAddPointTo == -1)
{
continue;
}
else
{
llArraysOfPointsAdding[cntrToAddPointTo].Add(currPtToClassify);
}
}
// распределили. теперь надо сформировать новые контуры - с учетом добавленных точек.
List <Image <Gray, byte> > lImagesToDetectNewContours = new List <Image <Gray, byte> >();
foreach (Tuple <Contour <Point>, Contour <Point> > tpl in currGroup)
{
Image <Gray, byte> tmpImgCurrCont = tmpImg1.CopyBlank();
tmpImgCurrCont.Draw(tpl.Item1, white, -1);
lImagesToDetectNewContours.Add(tmpImgCurrCont);
}
for (int cntIdx = 0; cntIdx < currGroup.Count(); cntIdx++)
{
foreach (Point pt in llArraysOfPointsAdding[cntIdx])
{
lImagesToDetectNewContours[cntIdx][pt.Y, pt.X] = white;
}
#region // obsolete
//Contour<Point> cnt1 =
// lImagesToDetectNewContours[cntIdx].FindContours(
// Emgu.CV.CvEnum.CHAIN_APPROX_METHOD.CV_CHAIN_APPROX_SIMPLE,
// Emgu.CV.CvEnum.RETR_TYPE.CV_RETR_LIST);
//List<Contour<Point>> lTmpCtrs = new List<Contour<Point>>();
//while (true)
//{
// lTmpCtrs.Add(cnt1);
// cnt1 = cnt1.HNext;
// if (cnt1 == null)
// break;
//}
#endregion // obsolete
////найдем наибольший из получившихся контуров
List <Contour <Point> > lTmpCtrs = lImagesToDetectNewContours[cntIdx].DetectContours();
foundClassesContours.Remove(currGroup.ElementAt(cntIdx).Item1);
double maxArea = lTmpCtrs.Max(cntr => cntr.Area);
int idxOfMaxAreaContour = lTmpCtrs.FindIndex(cntr => cntr.Area >= maxArea);
foundClassesContours.Add(lTmpCtrs[idxOfMaxAreaContour]);
}
}
}
}
else
{
foreach (Tuple <Contour <Point>, Contour <Point> > contourTuple in currSliceCoveringContours)
{
foundClassesContours.Remove(contourTuple.Item1);
foundClassesContours.Add(contourTuple.Item2);
}
}
//theLogWindow = ServiceTools.LogAText(theLogWindow,
// "processing thresholding value = " + currSlice.slicingThresholdingValue, true);
}
//theLogWindow = ServiceTools.LogAText(theLogWindow,
// Environment.NewLine +
// "========" + Environment.NewLine +
// "FINISHED" + Environment.NewLine +
// "========" + Environment.NewLine, true);
Image <Gray, Byte> imgDataBinary = ImageProcessing.grayscaleImageFromDenseMatrixWithFixedValuesBounds(dmDensityMesh, 0.0d, 1.0d);
Image <Bgr, byte> previewImage = imgDataBinary.CopyBlank().Convert <Bgr, Byte>();
var colorGen = new RandomPastelColorGenerator();
foreach (Contour <Point> currCntr in foundClassesContours)
{
Color currentColor = colorGen.GetNext();
var currentColorBgr = new Bgr(currentColor);
previewImage.Draw(currCntr, currentColorBgr, -1);
}
previewImage = previewImage.And(imgMask.Convert <Bgr, byte>());
ServiceTools.ShowPicture(previewImage, "");
}
public Image PlotSchedule(int width, int height, string filePath, bool printJobIndex = true)
{
RandomPastelColorGenerator colors = new RandomPastelColorGenerator();
Font font = new Font("courier new", 8);
const int X0 = 25; // margin left
const int X1 = 10; // margin right
int y0 = (int) (font.Size*3); // top margin
int y1 = (int) (font.Size*2); // bottom margin
double widthConvert = (width - X0 - X1)/(double) (Makespan);
int macheight = (height - y0 - y1)/_prob.NumMachines;
int space = (int) (macheight - font.Size*2); // space between machines
Brush blackBrush = new SolidBrush(Color.Black);
SolidBrush[] colorBrushes = new SolidBrush[_prob.NumJobs];
for (int job = 0; job < _prob.NumJobs; job++)
colorBrushes[job] = new SolidBrush(colors.GetNextRandom());
Bitmap imgSchedule = new Bitmap(width, height);
#region plot final resulting image
using (Graphics g = Graphics.FromImage(imgSchedule))
{
g.Clear(Color.White);
for (int mac = 0; mac < _prob.NumMachines; mac++)
g.DrawString(String.Format("{0}:", mac), font, blackBrush, new PointF(0, y0 + mac*macheight));
g.DrawString(String.Format("Cmax: {0}", Makespan), font, blackBrush, new PointF(0, height - y1));
for (int job = 0; job < _prob.NumJobs; job++)
{
for (int a = 0; a < _jobs[job].MacCount; a++)
{
int mac = _prob.Sigma[job, a];
int start = _jobs[job].XTime[mac];
int end = start + _prob.Procs[job, mac];
start = (int) (start*widthConvert) + X0;
end = (int) (end*widthConvert) + X0;
g.FillRectangle(colorBrushes[job],
new Rectangle(start, y0 + mac*macheight, end - start, macheight - space));
if (printJobIndex)
g.DrawString(job.ToString(), font, blackBrush, new PointF(start, y0 + mac*macheight));
}
}
g.Dispose();
}
#endregion
return imgSchedule;
}
