protected override Tuple <Term, Term[]> Reconstruct(SnappedStraightGenCylinder snappedPrimitive, Dictionary <FeatureCurve, ISet <Annotation> > curvesToAnnotations)
{
var silhouettesCount =
(new PointsSequence[] { snappedPrimitive.LeftSilhouette, snappedPrimitive.RightSilhouette })
.Count(curve => curve != null);
var featuresCount = snappedPrimitive.FeatureCurves
.Cast <CircleFeatureCurve>()
.Count(curve => curve.SnappedTo != null);
// get annotated feature curves of this primitive.
var annotated = new HashSet <FeatureCurve>(curvesToAnnotations.Keys.Where(key => curvesToAnnotations[key].Count > 0));
annotated.Intersect(snappedPrimitive.FeatureCurves);
// default objective function and no constraints.. if we can't match a case, we don't optimize.
Tuple <Term, Term[]> result = Tuple.Create(TermBuilder.Constant(0), new Term[0]);
if (silhouettesCount == 2 && featuresCount == 2)
{
result = FullInfo(snappedPrimitive);
}
else if (silhouettesCount == 1 && featuresCount == 2)
{
result = SingleSilhouetteTwoFeatures(snappedPrimitive, annotated);
}
else if (silhouettesCount == 2 && featuresCount == 1)
{
result = SingleFeatureTwoSilhouettes(snappedPrimitive, annotated);
}
return(result);
}
public SubstitutionResult Visit(Sum sum)
{
var summmandResults = sum.Terms.Select(x => x.Accept(this)).ToArray();
var nonConstants = new List <Term>();
double sumValue = 0;
foreach (var summandResult in summmandResults)
{
double value;
if (TryGetConstant(summandResult, out value))
{
sumValue += value;
}
else
{
nonConstants.Add(summandResult.Term);
}
}
if (nonConstants.Count == 0) // all are constants
{
return(CreateResult(sumValue));
}
else
{
var newSummands = nonConstants.Concat(Enumerable.Repeat(TermBuilder.Constant(sumValue), 1));
return(CreateResult(TermBuilder.Sum(newSummands)));
}
}
public void ConstantContract()
{
Assert.IsType <Constant>(TermBuilder.Constant(1));
Assert.IsType <Zero>(TermBuilder.Constant(0));
}
private static SubstitutionResult CreateResult(double value)
{
return(CreateResult(TermBuilder.Constant(value)));
}
