public CurveConverter(PointConverter ptConv, PipeConverter <rg.Plane, ppg.Plane> planeConv)
{
//converting lines
var lineConv = AddConverter(new PipeConverter <rg.Line, ppc.Line>(
(rl) => {
return(new ppc.Line(ptConv.ToPipe <rg.XYZ, ppg.Vec>(rl.GetEndPoint(0)),
ptConv.ToPipe <rg.XYZ, ppg.Vec>(rl.GetEndPoint(1))));
},
(ppl) => {
return(rg.Line.CreateBound(ptConv.FromPipe <rg.XYZ, ppg.Vec>(ppl.StartPoint),
ptConv.FromPipe <rg.XYZ, ppg.Vec>(ppl.EndPoint)));
}
));
//converting arcs
var arcConv = AddConverter(new PipeConverter <rg.Arc, ppc.Arc>(
(rarc) => {
ppg.Vec startPt = ptConv.ToPipe <rg.XYZ, ppg.Vec>(rarc.GetEndPoint(0));
ppg.Vec endPt = ptConv.ToPipe <rg.XYZ, ppg.Vec>(rarc.GetEndPoint(1));
ppg.Vec midPt = ptConv.ToPipe <rg.XYZ, ppg.Vec>(rarc.Evaluate(0.5, true));
return(new ppc.Arc(startPt, endPt, midPt));
},
(parc) => {
return(rg.Arc.Create(planeConv.FromPipe <rg.Plane, ppg.Plane>(parc.Plane), parc.Radius,
parc.StartAngle, parc.EndAngle));
}
));
//converting nurbs curves
var nurbsConv = AddConverter(new PipeConverter <rg.NurbSpline, ppc.NurbsCurve>(
(rnc) => {
return(new ppc.NurbsCurve(rnc.CtrlPoints.Select(
(pt) => ptConv.ToPipe <rg.XYZ, ppg.Vec>(pt)).ToList(), rnc.Degree, rnc.Weights.Cast <double>().ToList(),
rnc.Knots.Cast <double>().ToList(), rnc.isClosed));
},
null
));
var nurbsConv2 = AddConverter(new PipeConverter <rg.Curve, ppc.NurbsCurve>(
null,
(pnc) => {
if (pnc.IsClosed)
{
//revit doesn't support closed nurbs curves
Utils.RevitPipeUtil.ShowMessage("Conversion failed", "Closed NurbSplines are not supported",
"Revit doesn't support closed Nurbs curves. Revit's website says you can instead close one" +
"Nurbs curve with another.");
return(null);
}
var ptList = pnc.ControlPoints.Select((pt) => ptConv.FromPipe <rg.XYZ, ppg.Vec>(pt)).ToList();
return(rg.NurbSpline.CreateCurve(ptList, pnc.Weights.ToList()));
}
));
}
internal CurveConverter(PointConverter ptConv, VectorConverter vecConv)
{
var lineConv = new LineConverter(ptConv);
AddConverter(lineConv);
var arcConv = new ArcConverter(ptConv, vecConv);
AddConverter(arcConv);
//to convert nurbs curves
var nurbsConv = new PipeConverter <dg.NurbsCurve, ppc.NurbsCurve>(
(dc) => {
////just to smooth out anything weird about this curve
//dc = dc.ToNurbsCurve();
ppc.NurbsCurve cur;
List <dg.Point> pts = dc.ControlPoints().ToList();
List <double> knots = dc.Knots().ToList();
var startParam = dc.StartParameter();
var endParam = dc.EndParameter();
knots = knots.Select((k) => (k - startParam) / (endParam - startParam)).ToList();
//making sure all the weights are not zeros by setting them to 1 if they are
double tolerance = 1e-4;
List <double> weights = dc.Weights().ToList();
if (weights.Any((w) => w <= tolerance))
{
weights = weights.Select((w) => 1.0).ToList();
}
cur = new ppc.NurbsCurve(pts.Select((pt) => ptConv.ToPipe <dg.Point, ppg.Vec>(pt)).ToList(),
dc.Degree, weights, knots, dc.IsClosed);
return(cur);
},
(pnc) => {
dg.NurbsCurve cur;
try
{
cur = dg.NurbsCurve.ByControlPointsWeightsKnots(
pnc.ControlPoints.Select((pt) => ptConv.FromPipe <dg.Point, ppg.Vec>(pt)),
pnc.Weights.ToArray(), pnc.Knots.ToArray(), pnc.Degree);
if (pnc.IsClosed != cur.IsClosed)
{
cur = dg.NurbsCurve.ByControlPoints(
pnc.ControlPoints.Select((pt) => ptConv.FromPipe <dg.Point, ppg.Vec>(pt)), pnc.Degree,
pnc.IsClosed);
}
}
catch (Exception e)
{
cur = dg.NurbsCurve.ByControlPoints(
pnc.ControlPoints.Select((pt) => ptConv.FromPipe <dg.Point, ppg.Vec>(pt)), pnc.Degree,
pnc.IsClosed);
}
return(cur);
}
);
AddConverter(nurbsConv);
//generic curves - one way conversion, hence one of the conversion delegates is null
AddConverter(new PipeConverter <dg.Curve, ppc.Curve>(
(dc) => {
return(nurbsConv.ToPipe <dg.NurbsCurve, ppc.NurbsCurve>(dc.ToNurbsCurve()));
},
null
));
//conversion for polycurves
var polyCurveConv = new PipeConverter <dg.PolyCurve, ppc.PolyCurve>(
(dpc) => {
dg.Curve[] curs = dpc.Curves();
return(new ppc.PolyCurve(curs.Select((c) => ToPipe <dg.Curve, ppc.Curve>(c)).ToList()));
},
(ppcrv) => {
try
{
List <dg.Curve> curves = ppcrv.Segments.Select((c) => FromPipe <dg.Curve, ppc.Curve>(c)).ToList();
return(dg.PolyCurve.ByJoinedCurves(curves));
}
catch (Exception e)
{
return(null);
}
}
);
AddConverter(polyCurveConv);
//one way conversion for incoming polylines
var plineConv = new PipeConverter <dg.PolyCurve, ppc.Polyline>(
null,
(ppl) => {
return(polyCurveConv.FromPipe <dg.PolyCurve, ppc.PolyCurve>(ppl.AsPolyCurve()));
}
);
}
