private Tuple <Term, Term[]> SingleSilhouetteTwoFeatures(SnappedStraightGenCylinder snappedPrimitive, HashSet <FeatureCurve> annotated)
{
var pts =
snappedPrimitive.LeftSilhouette != null
? snappedPrimitive.LeftSilhouette.Points
: snappedPrimitive.RightSilhouette.Points;
var pointsProgress =
snappedPrimitive.Components.Select(x => x.Progress).ToArray();
// compute the term we get from the feature curves. used mainly to optimize
// for the axis orientation
var topEllipse = EllipseFitter.Fit(snappedPrimitive.TopFeatureCurve.SnappedTo.Points);
var botEllipse = EllipseFitter.Fit(snappedPrimitive.BottomFeatureCurve.SnappedTo.Points);
var approxOrientation = GetOrientation(topEllipse, botEllipse, snappedPrimitive.AxisResult);
var spine = StraightSpine.Compute(pts, pointsProgress, topEllipse.Center, topEllipse.Center - botEllipse.Center);
var radii = spine.Item1;
var spineStart = spine.Item2;
var spineEnd = spine.Item3;
return(CreateSGCTerms(snappedPrimitive, radii, spineStart, spineEnd));
}
private Tuple <Term, Term[]> FullInfo(SnappedStraightGenCylinder snappedPrimitive)
{
var leftPts = snappedPrimitive.LeftSilhouette.Points;
var rightPts = snappedPrimitive.RightSilhouette.Points;
var totPts = leftPts.Concat(rightPts).ToArray();
var pointsProgress =
snappedPrimitive.Components.Select(x => x.Progress).ToArray();
// compute the term we get from the feature curves. used mainly to optimize
// for the axis orientation
var topEllipse = EllipseFitter.Fit(snappedPrimitive.TopFeatureCurve.SnappedTo.Points);
var botEllipse = EllipseFitter.Fit(snappedPrimitive.BottomFeatureCurve.SnappedTo.Points);
//var approxOrientation = GetOrientation(topEllipse, botEllipse, snappedPrimitive.AxisResult);
var approxOrientation = NewGetOrientation(snappedPrimitive.TopFeatureCurve.SnappedTo.Points, snappedPrimitive.BottomFeatureCurve.SnappedTo.Points, topEllipse, botEllipse, snappedPrimitive.AxisResult);
// compute the spine of the primitive
var spine = StraightSpine.Compute(leftPts, rightPts, pointsProgress, topEllipse.Center, topEllipse.Center - botEllipse.Center);
var radii = spine.Item1;
var spineStart = spine.Item2;
var spineEnd = spine.Item3;
return(CreateSGCTerms(snappedPrimitive, radii, spineStart, spineEnd));
}
private Tuple <Term, Term[]> SingleFeatureTwoSilhouettes(SnappedStraightGenCylinder snappedPrimitive, HashSet <FeatureCurve> annotated)
{
//MessageBox.Show("Inside Two Silhouettes one Feature");
var leftPts = snappedPrimitive.LeftSilhouette.Points;
var rightPts = snappedPrimitive.RightSilhouette.Points;
var pointsProgress = snappedPrimitive.Components.Select(x => x.Progress).ToArray();
Point[] featureCurve;
if (snappedPrimitive.TopFeatureCurve.SnappedTo != null)
{
featureCurve = snappedPrimitive.TopFeatureCurve.SnappedTo.Points;
}
else
{
featureCurve = snappedPrimitive.BottomFeatureCurve.SnappedTo.Points;
}
var ellipse = EllipseFitter.Fit(featureCurve);
var orientationBasis = EllipseHelper.CircleOrientation(ellipse);
var approxOrientation = GetOrientation(orientationBasis, snappedPrimitive.AxisResult);
var spine = StraightSpine.Compute(leftPts, rightPts, pointsProgress, new Vector(approxOrientation.X, -approxOrientation.Y));
var radii = spine.Item1;
var spineStart = spine.Item2;
var spineEnd = spine.Item3;
return(CreateSGCTerms(snappedPrimitive, radii, spineStart, spineEnd));
}
public static void ValidateFeatureCurves(this NewPrimitive primitive)
{
int N = 2;
Point[][] EndPoints = new Point[N][];
for (int count = 0; count < N; count++)
{
EndPoints[count] = new Point[2];
}
bool[] bitRaised = new bool[N];
int SilhouettesCount = 0;
int i = 0;
if (primitive.SilhouetteCurves.Length > 0 && primitive.SilhouetteCurves[0].AssignedTo != null)
{
EndPoints[i][0] = primitive.SilhouetteCurves[0].AssignedTo.Points[0];
EndPoints[i][1] = primitive.SilhouetteCurves[0].AssignedTo.Points.Last();
SilhouettesCount++;
i++;
}
if (primitive.SilhouetteCurves.Length > 1 && primitive.SilhouetteCurves[1].AssignedTo != null)
{
EndPoints[i][0] = primitive.SilhouetteCurves[1].AssignedTo.Points[0];
EndPoints[i][1] = primitive.SilhouetteCurves[1].AssignedTo.Points.Last();
SilhouettesCount++;
i++;
}
if (primitive.FeatureCurves.Length > 0 && primitive.FeatureCurves[0].AssignedTo != null)
{
var FeatureCurve1 = primitive.FeatureCurves[0].AssignedTo;
Point[] EndFeaturePoints = new Point[2];
EndFeaturePoints[0] = FindClosestPoint(FeatureCurve1, EndPoints[0]);
EndFeaturePoints[1] = FindClosestPoint(FeatureCurve1, EndPoints[1]);
var Ellipse = EllipseFitter.Fit(FeatureCurve1.Points);
double maxperimeter = Ellipse.XRadius > Ellipse.YRadius ? 2 * Ellipse.XRadius : 2 * Ellipse.YRadius;
Vector v = new Vector(EndFeaturePoints[0].X - EndFeaturePoints[1].X, EndFeaturePoints[0].Y - EndFeaturePoints[1].Y);
if (Math.Min(maxperimeter, v.Length) / Math.Max(maxperimeter, v.Length) < 0.67)
{
primitive.FeatureCurves[0].AssignedTo = null;
}
}
if (primitive.FeatureCurves.Length > 0 && primitive.FeatureCurves[1].AssignedTo != null)
{
var FeatureCurve1 = primitive.FeatureCurves[1].AssignedTo;
Point[] EndFeaturePoints = new Point[2];
EndFeaturePoints[0] = FindClosestPoint(FeatureCurve1, EndPoints[0]);
EndFeaturePoints[1] = FindClosestPoint(FeatureCurve1, EndPoints[1]);
var Ellipse = EllipseFitter.Fit(FeatureCurve1.Points);
double maxperimeter = Ellipse.XRadius > Ellipse.YRadius ? 2 * Ellipse.XRadius : 2 * Ellipse.YRadius;
Vector v = new Vector(EndFeaturePoints[0].X - EndFeaturePoints[1].X, EndFeaturePoints[0].Y - EndFeaturePoints[1].Y);
if (Math.Min(maxperimeter, v.Length) / Math.Max(maxperimeter, v.Length) < 0.67)
{
primitive.FeatureCurves[1].AssignedTo = null;
}
}
}
public GeometricClass Classify(PointsSequence p)
{
var points = p.Points;
var xAvg = points.Select(pnt => pnt.X).Average();
var yAvg = points.Select(pnt => pnt.Y).Average();
var shiftedPoints =
from pnt in points
select new Point(pnt.X - xAvg, pnt.Y - yAvg);
var mvSample = new MultivariateSample(2);
foreach (var pnt in shiftedPoints)
{
mvSample.Add(pnt.X, pnt.Y);
}
var pca = mvSample.PrincipalComponentAnalysis();
var firstSize = pca.Component(0).ScaledVector().Norm();
var secondSize = pca.Component(1).ScaledVector().Norm();
var fraction = secondSize / firstSize;
if (fraction < pcaFractionThreshold)
{
return(GeometricClass.Line);
}
else
{
var conicEllipse = EllipseFitter.ConicFit(p.Points);
var parametricEllipse = EllipseFitter.Fit(p.Points);
var deviations =
from pnt in p.Points
select EllipseFitter.ComputeDeviation(conicEllipse, parametricEllipse, pnt);
var avgDeviation = deviations.Average();
if (avgDeviation < ellipseFitThreshold)
{
return(GeometricClass.Ellipse);
}
else
{
return(GeometricClass.Line);
}
}
}
/// <summary>
/// Checks weather a points sequence is the top-part of a cylinder, by comparing the center of the ellipse that best fits the points
/// sequence to the actual top center and bottom centers.
/// </summary>
/// <param name="points">The points sequence</param>
/// <param name="cylinder">The cylinder data</param>
/// <returns><c>true</c> if the best-fit-ellipse's center is closer to the top cylinder point than to the bottom.</returns>
public static bool IsTop(PointsSequence points, SnappedCylindricalPrimitive cylinder)
{
var top = new Point(cylinder.TopCenterResult.X, -cylinder.TopCenterResult.Y);
var bottom = new Point(cylinder.BottomCenterResult.X, -cylinder.BottomCenterResult.Y);
var samples = CurveSampler.UniformSample(points, 50);
var ellipse = EllipseFitter.Fit(samples);
// the points sequence is "top" if it is closer to the top center then it is to the bottom center.
if ((top - ellipse.Center).Length < (bottom - ellipse.Center).Length)
{
return(true);
}
else
{
return(false);
}
}
public static void GetLargestComponet(this NewPrimitive primitive, bool FirstSilhouette = false)
{
var ActiveCurves = primitive.AllCurves
.Select(c => c)
.Where(c => c.AssignedTo != null)
.ToArray();
int N = ActiveCurves.Length;
Point[][] EndPoints = new Point[N][];
//Debug.WriteLine("Number of Active Curves="+N);
//Debug.WriteLine("Feature Curves Number : " + primitive.FeatureCurves.Length);
//Debug.WriteLine("Silhouette Curves Number : " + primitive.SilhouetteCurves.Length);
bool[] ActiveFeatureCurve = { true, true };
for (int count = 0; count < N; count++)
{
EndPoints[count] = new Point[2];
}
bool[] bitRaised = new bool[N];
int SilhouettesCount = 0;
int i = 0;
if (primitive.SilhouetteCurves.Length > 0 && primitive.SilhouetteCurves[0].AssignedTo != null)
{
EndPoints[i][0] = primitive.SilhouetteCurves[0].AssignedTo.Points[0];
EndPoints[i][1] = primitive.SilhouetteCurves[0].AssignedTo.Points.Last();
SilhouettesCount++;
i++;
}
if (primitive.SilhouetteCurves.Length > 1 && primitive.SilhouetteCurves[1].AssignedTo != null)
{
EndPoints[i][0] = primitive.SilhouetteCurves[1].AssignedTo.Points[0];
EndPoints[i][1] = primitive.SilhouetteCurves[1].AssignedTo.Points.Last();
SilhouettesCount++;
i++;
}
//PointsSequence FeatureCurve1 = new PointsSequence();
if (primitive.FeatureCurves.Length > 0 && primitive.FeatureCurves[0].AssignedTo != null)
{
var FeatureCurve1 = primitive.FeatureCurves[0].AssignedTo;
if (SilhouettesCount > 0)
{
EndPoints[i][0] = FindClosestPoint(FeatureCurve1, EndPoints[0]);
}
if (SilhouettesCount > 1)
{
EndPoints[i][1] = FindClosestPoint(FeatureCurve1, EndPoints[1]);
}
else if (SilhouettesCount > 0)
{
EndPoints[i][1] = EndPoints[i][0];
}
if (SilhouettesCount > 0)
{
var Ellipse = EllipseFitter.Fit(FeatureCurve1.Points);
double maxperimeter = Ellipse.XRadius > Ellipse.YRadius ? 2 * Ellipse.XRadius : 2 * Ellipse.YRadius;
Vector v = new Vector(EndPoints[i][0].X - EndPoints[i][1].X, EndPoints[i][0].Y - EndPoints[i][1].Y);
if (Math.Min(maxperimeter, v.Length) / Math.Max(maxperimeter, v.Length) < 0.7)
{
ActiveFeatureCurve[0] = false;
}
if (!ActiveFeatureCurve[0])
{
EndPoints[i][0].X = 10e11;
EndPoints[i][1].X = 10e11;
EndPoints[i][0].Y = 10e11;
EndPoints[i][1].Y = 10e11;
}
i++;
}
}
if (primitive.FeatureCurves.Length > 1 && primitive.FeatureCurves[1].AssignedTo != null)
{
var FeatureCurve2 = primitive.FeatureCurves[1].AssignedTo;
if (SilhouettesCount > 0)
{
EndPoints[i][0] = FindClosestPoint(FeatureCurve2, EndPoints[0]);
}
if (SilhouettesCount > 1)
{
EndPoints[i][1] = FindClosestPoint(FeatureCurve2, EndPoints[1]);
}
else if (SilhouettesCount > 0)
{
EndPoints[i][1] = EndPoints[i][0];
}
if (SilhouettesCount > 0)
{
var Ellipse = EllipseFitter.Fit(FeatureCurve2.Points);
double maxperimeter = Ellipse.XRadius > Ellipse.YRadius ? 2 * Ellipse.XRadius : 2 * Ellipse.YRadius;
Vector v = new Vector(EndPoints[i][0].X - EndPoints[i][1].X, EndPoints[i][0].Y - EndPoints[i][1].Y);
if (Math.Min(maxperimeter, v.Length) / Math.Max(maxperimeter, v.Length) < 0.7)
{
ActiveFeatureCurve[1] = false;
}
if (!ActiveFeatureCurve[1])
{
EndPoints[i][0].X = 10e10;
EndPoints[i][1].X = 10e10;
EndPoints[i][0].Y = 10e10;
EndPoints[i][1].Y = 10e10;
}
i++;
}
}
List <int>[] ConnectedComponents = new List <int> [N];
for (int count = 0; count < N; count++)
{
ConnectedComponents[count] = new List <int>();
}
for (int count = 0; count < N; count++)
{
ConnectedComponents[count].Add(count);
}
//int offset = 1;
for (int pivot = 0; pivot < N; pivot++)
{
for (int count = 0; count < N; count++)
{
if (pivot != count)
{
if (PointCompare(EndPoints[pivot], EndPoints[count]))
{
foreach (int c in ConnectedComponents[count])
{
if (!(ConnectedComponents[pivot].Contains(c)))
{
ConnectedComponents[pivot].Add(c);
}
}
}
}
}
}
int Max = ConnectedComponents[0].Count;
int idx = 0;
for (int counter = 1; counter < N; counter++)
{
if (ConnectedComponents[counter].Count > Max)
{
Max = ConnectedComponents[counter].Count;
idx = counter;
}
}
//Debug.WriteLine("Curves in Component = " + Max);
foreach (int c in ConnectedComponents[idx])
{
bitRaised[c] = true;
}
for (int counter = 0; counter < N; counter++)
{
if (!bitRaised[counter])
{
/*ActiveCurves[counter].AssignedTo.isdeselected = true;
* ActiveCurves[counter].AssignedTo = null;*/
if (counter == 1)
{
primitive.SilhouetteCurves[counter].AssignedTo.isdeselected = true;
primitive.SilhouetteCurves[counter].AssignedTo = null;
}
else if (counter == 0 && FirstSilhouette)
{
primitive.SilhouetteCurves[counter].AssignedTo.isdeselected = true;
//primitive.SilhouetteCurves[counter].AssignedTo = null;
}
else if (counter > 1)
{
primitive.FeatureCurves[counter - 2].AssignedTo.isdeselected = true;
primitive.FeatureCurves[counter - 2].AssignedTo = null;
}
}
else
{
if (counter > 1)
{
if (!ActiveFeatureCurve[counter - 2])
{
primitive.FeatureCurves[counter - 2].AssignedTo.isdeselected = true;
primitive.FeatureCurves[counter - 2].AssignedTo = null;
}
}
}
}
}
