//--------------------------------------------------------------------------------------------------
MemoryStream _Export(VectorExportLayer[] layers)
{
// Create group
var group = new SvgGroupElement
{
ID = _Template.ToString(),
IsLayer = _Template == VectorExportTemplate.Contours
};
BoundingBox = new Bnd_Box2d();
// Export
foreach (var layer in layers)
{
var subgroup = _ExportLayer(layer);
if (subgroup != null)
{
group.Children.Add(subgroup);
}
}
// Scale
double width = 100;
double height = 100;
if (!BoundingBox.IsVoid())
{
BoundingBox.SetGap(10.0); // 1cm on each side
double xmin = 0, xmax = 0, ymin = 0, ymax = 0;
BoundingBox.Get(ref xmin, ref ymin, ref xmax, ref ymax);
width = xmax - xmin;
height = ymax - ymin;
group.Transforms.Add(new SvgTranslateTransform(-xmin, -ymax));
}
// Create Document
var doc = new SvgDocument {
DotsPerInch = DotsPerInch,
Width = width,
Height = height
};
doc.Children.Add(group);
return(doc.WriteToStream());
}
//--------------------------------------------------------------------------------------------------
SvgGroupElement _ExportLayer(VectorExportLayer layer)
{
if (_Styles == null || !_Styles.TryGetValue(layer.Type, out var lineStyle))
{
return(null);
}
CurrentGroup = new SvgGroupElement
{
ID = layer.Name,
Style = lineStyle
};
if (layer.BRep == null)
{
return(null);
}
if (_Template == VectorExportTemplate.Contours)
{
CurrentGroup.IsLayer = true;
}
CurrentPath = null;
if (_Template == VectorExportTemplate.Drawing)
{
// Drawings do only contain lines
CombineToPath = false;
_ExportEdges(layer.BRep.Edges(), null);
}
else
{
CombineToPath = layer.Type.HasFlag(VectorExportLayerType.Filled);
var faces = layer.BRep.Faces();
foreach (var face in faces)
{
var outerWire = BRepTools.OuterWire(face);
if (outerWire == null)
{
continue;
}
_ExportEdges(outerWire.Edges(), face);
var wires = face.Wires();
foreach (var wire in wires)
{
if (wire.IsEqual(outerWire))
{
continue;
}
_ExportEdges(wire.Edges(), face);
}
FinalizePath();
}
}
if (CurrentGroup.Children.Any())
{
return(CurrentGroup);
}
return(null);
}
//--------------------------------------------------------------------------------------------------
MemoryStream _Export()
{
_Group = new SvgGroupElement
{
ID = _Sketch.Name,
Style = new SvgStyle {
StrokeWidth = 0.1f, StrokeColor = Color.Black, FillColor = null
}
};
var freeSegments = new Dictionary <int, SketchSegment>(_Sketch.Segments);
while (freeSegments.Any())
{
var currentSegmentKvp = freeSegments.First();
freeSegments.Remove(currentSegmentKvp.Key);
var currentSegment = currentSegmentKvp.Value;
if ((currentSegment.StartPoint == -1) || (currentSegment.EndPoint == -1))
{
// Unconnected segment
_AddUnconnectableSegment(currentSegment);
continue;
}
// Start path
_CurrentPath = new SvgPathElement();
_FirstPathEndPoint = -1;
_LastPathEndPoint = -1;
// search for connected
while (freeSegments.Any())
{
currentSegmentKvp = freeSegments.FirstOrDefault(kvp => kvp.Value.IsConnected(currentSegment));
if (currentSegmentKvp.Value == null)
{
// disconnected segment
break;
}
if (_FirstPathEndPoint == -1)
{
// First connection, get winding order and write the move to start position
if ((currentSegment.EndPoint == currentSegmentKvp.Value.StartPoint) ||
(currentSegment.EndPoint == currentSegmentKvp.Value.EndPoint))
{
var startPoint = _Sketch.Points[currentSegment.StartPoint];
_CurrentPath.Segments.Add(new SvgPathSegMoveto(startPoint));
_LastPathEndPoint = currentSegment.StartPoint;
_FirstPathEndPoint = currentSegment.StartPoint;
}
else
{
var startPoint = _Sketch.Points[currentSegment.EndPoint];
_CurrentPath.Segments.Add(new SvgPathSegMoveto(startPoint));
_LastPathEndPoint = currentSegment.EndPoint;
_FirstPathEndPoint = currentSegment.EndPoint;
}
// add first element
if (!_AddPathSegment(currentSegment))
{
break;
}
}
// Next connected, write
currentSegment = currentSegmentKvp.Value;
freeSegments.Remove(currentSegmentKvp.Key);
if (!_AddPathSegment(currentSegment))
{
break;
}
}
if (_LastPathEndPoint == -1)
{
// Standalone element, write as single segment
var startPoint = _Sketch.Points[currentSegment.StartPoint];
_CurrentPath.Segments.Add(new SvgPathSegMoveto(startPoint));
_AddPathSegment(currentSegment);
}
// Close segment, if needed
if (_FirstPathEndPoint == _LastPathEndPoint)
{
_CurrentPath.Segments.Add(new SvgPathSegClosePath());
}
// Add to group
_Group.Children.Add(_CurrentPath);
}
var doc = new SvgDocument
{
Width = 100,
Height = 100,
DotsPerInch = DotsPerInch
};
doc.Children.Add(_Group);
return(doc.WriteToStream());
}
internal virtual bool Read(XmlReader reader, SvgConverter conv)
{
var transformString = reader.GetAttribute("transform");
if (!transformString.IsNullOrEmpty())
{
Transforms.AddRange(SvgTransform.Create(transformString, conv));
}
conv.PushTransform(Transforms);
var depth = reader.Depth;
reader.Read();
while (!reader.EOF && reader.Depth > depth)
{
if (reader.NodeType != XmlNodeType.Element)
{
reader.Read();
continue;
}
SvgElement newElement = null;
switch (reader.LocalName.ToLower())
{
case "g":
newElement = new SvgGroupElement();
break;
case "circle":
newElement = new SvgCircleElement();
break;
case "ellipse":
newElement = new SvgEllipseElement();
break;
case "path":
newElement = new SvgPathElement();
break;
case "line":
newElement = new SvgLineElement();
break;
case "rect":
newElement = new SvgRectElement();
break;
}
if (newElement != null)
{
if (newElement.Read(reader, conv))
{
Children.Add(newElement);
}
}
else
{
reader.Skip();
}
}
return(true);
}
//--------------------------------------------------------------------------------------------------
void _ImportGroup(SvgGroupElement group)
{
}
