public void BoxByVertex()
{
var box = TestGeomGenerator.CreateBox();
var face = box.GetSubshapeReference(SubshapeType.Face, 1);
var vertex = box.GetSubshapeReference(SubshapeType.Vertex, 5);
var taper = Taper.Create(box.Body, face, vertex, 22.5);
// Edge orientation is Rev, Fwd
Assert.IsTrue(taper.Make(Shape.MakeFlags.None));
AssertHelper.IsSameModel(taper, Path.Combine(_BasePath, "BoxByVertex1"));
// Edge orientation is Rev, Rev
taper.BaseEdgeOrVertex = box.GetSubshapeReference(SubshapeType.Vertex, 4);
Assert.IsTrue(taper.Make(Shape.MakeFlags.None));
AssertHelper.IsSameModel(taper, Path.Combine(_BasePath, "BoxByVertex2"));
// Edge orientation is Rev, Fwd
taper.BaseEdgeOrVertex = box.GetSubshapeReference(SubshapeType.Vertex, 6);
Assert.IsTrue(taper.Make(Shape.MakeFlags.None));
AssertHelper.IsSameModel(taper, Path.Combine(_BasePath, "BoxByVertex3"));
// Edge orientation is Fwd, Fwd
taper.BaseEdgeOrVertex = box.GetSubshapeReference(SubshapeType.Vertex, 7);
Assert.IsTrue(taper.Make(Shape.MakeFlags.None));
AssertHelper.IsSameModel(taper, Path.Combine(_BasePath, "BoxByVertex4"));
}
public void BoxByEdgeAdd()
{
var box = TestGeomGenerator.CreateBox();
var face = box.GetSubshapeReference(SubshapeType.Face, 1);
var edge = box.GetSubshapeReference(SubshapeType.Edge, 4);
var taper = Taper.Create(box.Body, face, edge, -22.5);
Assert.IsTrue(taper.Make(Shape.MakeFlags.None));
AssertHelper.IsSameModel(taper, Path.Combine(_BasePath, "BoxByEdgeAdd"));
}
//--------------------------------------------------------------------------------------------------
/// <summary>
/// Reselect target face of an taper shape.
/// </summary>
public CreateTaperTool(Taper taperToChange)
{
_TaperToChange = taperToChange;
Debug.Assert(_TaperToChange != null);
_TargetBody = _TaperToChange.Body;
Debug.Assert(_TargetBody != null);
_TargetShape = _TaperToChange.Operands[0] as Shape;
Debug.Assert(_TargetShape != null);
_Mode = ToolMode.Reselect;
}
public void ConcaveVertex()
{
var body = TestData.GetBodyFromBRep(Path.Combine(_BasePath, "BoxJointShape_Source.brep"));
var face = body.Shape.GetSubshapeReference(SubshapeType.Face, 13);
var vertex = body.Shape.GetSubshapeReference(SubshapeType.Vertex, 16);
var taper = Taper.Create(body, face, vertex, 3.0);
Assert.IsTrue(taper.Make(Shape.MakeFlags.None));
AssertHelper.IsSameModel(taper, Path.Combine(_BasePath, "ConcaveVertex"));
}
public void CylinderSurface()
{
var cylinder = Cylinder.Create(10, 10);
Body.Create(cylinder);
var face = cylinder.GetSubshapeReference(SubshapeType.Face, 0);
var edge = cylinder.GetSubshapeReference(SubshapeType.Edge, 2);
var taper = Taper.Create(cylinder.Body, face, edge, 22.5);
Assert.IsTrue(taper.Make(Shape.MakeFlags.None));
AssertHelper.IsSameModel(taper, Path.Combine(_BasePath, "CylinderSurface"));
}
//--------------------------------------------------------------------------------------------------
bool _GetPreviewAxis(SelectSubshapeAction selectAction, out Ax1 axis)
{
if (selectAction.SelectedSubshapeType == SubshapeTypes.Edge)
{
var edge = selectAction.SelectedSubshape.ToEdge();
var edgeParam = _FindEdgeParam(edge, selectAction);
return(Taper.ComputeAxisFromEdge(_TargetFace, edge, edgeParam, out axis));
}
if (selectAction.SelectedSubshapeType == SubshapeTypes.Vertex)
{
var vertex = selectAction.SelectedSubshape.ToVertex();
return(Taper.ComputeAxisFromVertex(_TargetFace, vertex, out axis));
}
axis = Ax1.OX;
return(false);
}
public void NoAutoFaceDetection()
{
Context.InitWithView(500);
var ctx = Context.Current;
// Create a shape with a planar face, but without an opposite face
var cylinder = Cylinder.Create(10, 10);
var body = Body.Create(cylinder);
var face = cylinder.GetSubshapeReference(SubshapeType.Face, 1);
var edge = cylinder.GetSubshapeReference(SubshapeType.Edge, 0);
var taper = Taper.Create(cylinder.Body, face, edge, 22.5);
taper.BaseParameter = 0.0;
Assert.IsTrue(taper.Make(Shape.MakeFlags.None));
ctx.Document.AddChild(body);
ctx.ViewportController.ZoomFitAll();
// Start tool
ctx.WorkspaceController.Selection.SelectEntity(body);
Assert.IsTrue(ToolboxCommands.CreateEtchingMask.CanExecute());
ToolboxCommands.CreateEtchingMask.Execute();
var tool = ctx.WorkspaceController.CurrentTool as EtchingMaskEditTool;
Assert.IsNotNull(tool);
Assert.IsNotNull(ctx.WorkspaceController.CurrentToolAction);
// Check selection filter
ctx.MoveTo(150, 300);
AssertHelper.IsSameViewport(Path.Combine(_BasePath, "NoAutoFaceDetection02"));
ctx.MoveTo(250, 250);
AssertHelper.IsSameViewport(Path.Combine(_BasePath, "NoAutoFaceDetection01"));
ctx.ClickAt(250, 250);
Assert.IsNull(ctx.WorkspaceController.CurrentToolAction);
// Component should exist, even if it can not work correctly
var component = body.FindComponent <EtchingMaskComponent>();
Assert.IsNotNull(component);
Assert.IsFalse(component.IsValid);
}
//--------------------------------------------------------------------------------------------------
double _FindEdgeParam(TopoDS_Edge edge, SelectSubshapeAction selectAction)
{
// Calculate parameter on the edge
double umin = 0, umax = 0;
var curve = BRep_Tool.Curve(edge, ref umin, ref umax);
var viewAxis = selectAction.LastMouseEventData.PickAxis;
var extrema = new GeomAPI_ExtremaCurveCurve(curve, new Geom_Line(viewAxis));
if (extrema.NbExtrema() > 0)
{
double param1 = 0, param2 = 0;
extrema.LowerDistanceParameters(ref param1, ref param2);
return(param1);
}
else
{
return(Taper.CalculateBaseParameter(edge, 0.5));
}
}
public void CurvedEdges()
{
var cylinder = Cylinder.Create(10, 10);
cylinder.SegmentAngle = 270;
Body.Create(cylinder);
var face = cylinder.GetSubshapeReference(SubshapeType.Face, 1);
var edge = cylinder.GetSubshapeReference(SubshapeType.Edge, 0);
var taper = Taper.Create(cylinder.Body, face, edge, 22.5);
Assert.IsTrue(taper.Make(Shape.MakeFlags.None));
AssertHelper.IsSameModel(taper, Path.Combine(_BasePath, "CurvedEdges1"));
edge = cylinder.GetSubshapeReference(SubshapeType.Edge, 4);
taper.BaseEdgeOrVertex = edge;
Assert.IsTrue(taper.Make(Shape.MakeFlags.None));
AssertHelper.IsSameModel(taper, Path.Combine(_BasePath, "CurvedEdges2"));
}
public void ErrorMarker()
{
var ctx = Context.Current;
var box = TestGeomGenerator.CreateBox();
var face = box.GetSubshapeReference(SubshapeType.Face, 1);
var edge = box.GetSubshapeReference(SubshapeType.Edge, 4);
var taper = Taper.Create(box.Body, face, edge, 22.5);
ctx.ViewportController.ZoomFitAll();
Assert.Multiple(() =>
{
AssertHelper.IsSameViewport(Path.Combine(_BasePath, "ErrorMarkerInvisible"));
taper.Angle = 80;
AssertHelper.IsSameViewport(Path.Combine(_BasePath, "ErrorMarkerVisible"));
taper.Angle = 22.5;
AssertHelper.IsSameViewport(Path.Combine(_BasePath, "ErrorMarkerInvisible"));
});
}
private void loadSpeciesList()
{
// var file = Package.Current.InstalledLocation.GetFolderAsync("Assets\\FireFlyData.xml");
var path = System.IO.Path.Combine(Package.Current.InstalledLocation.Path, "Assets\\FireFlyData.xml");
// var file = WebRoot.GetFileAsync("FireFlyData.xml");
XDocument doc;
try
{
doc = XDocument.Load(path);
}
catch (Exception)
{
throw;
}
var xmldoc = XDocument.Parse(doc.ToString());
var SpList = (from mainRequest in xmldoc.Descendants("Species")
select new
{
Name = mainRequest.Element("Name").Value,
ShortName = mainRequest.Element("ShortName").Value,
Flashes = (from flash in mainRequest.Descendants("Flash")
select new
{
sex = flash.Element("sex").Value,
ResponseTime = flash.Element("ResponseTime").Value,
QorA = flash.Element("QorA").Value,
quantity = flash.Element("quantity").Value,
TaperMultiple = flash.Element("TaperMultiple").Value,
delay = flash.Element("delay").Value,
Tapers = (from taper in flash.Descendants("Taper")
select new
{
Repeat = taper.Element("Repeat").Value,
RepeatQty = taper.Element("RepeatQty").Value,
RepeatDelay = taper.Element("RepeatDelay").Value,
StartIntensity = taper.Element("StartIntensity").Value,
Duration = taper.Element("Duration").Value,
EndIntensity = taper.Element("EndIntensity").Value,
TaperDirection = taper.Element("TaperDirection").Value
})
})
});
SpeciesList = new List <Species>();
foreach (var i in SpList)
{
// Fireflies.FireFly f = new Fireflies.FireFly();
Species s = new Species();
s.Name = i.Name;
s.ShortName = i.ShortName;
s.Flashes = new List <Flash>();
foreach (var j in i.Flashes)
{
Flash fl = new Flash();
fl.Tapers = new List <Taper>();
fl.sex = j.sex;
fl.QorA = j.QorA;
fl.ResponseTime = Convert.ToDouble(j.ResponseTime);
// fl.Duration = Convert.ToDouble(j.Duration);
fl.delay = Convert.ToDouble(j.delay);
fl.TaperMultiple = Convert.ToBoolean(j.TaperMultiple);
fl.quantity = Convert.ToInt16(j.quantity);
// fl.Intensity = Convert.ToInt16(j.Intensity);
foreach (var k in j.Tapers)
{
Taper t = new Taper();
t.Repeat = Convert.ToBoolean(k.Repeat);
t.RepeatQty = Convert.ToInt16(k.RepeatQty);
t.RepeatDelay = Convert.ToDouble(k.RepeatDelay);
t.Duration = Convert.ToUInt16(k.Duration);
t.EndIntensity = Convert.ToUInt16(k.EndIntensity);
t.StartIntensity = Convert.ToUInt16(k.StartIntensity);
switch (k.TaperDirection)
{
case "UP":
t.TaperDirection = Taper.TaperType.UP;
break;
case "DOWN":
t.TaperDirection = Taper.TaperType.DOWN;
break;
case "NONE":
t.TaperDirection = Taper.TaperType.NONE;
break;
case "FLAT":
t.TaperDirection = Taper.TaperType.FLAT;
break;
default:
t.TaperDirection = Taper.TaperType.NONE;
break;
}
fl.Tapers.Add(t);
}
s.Flashes.Add(fl);
}
SpeciesList.Add(s);
}
}
//--------------------------------------------------------------------------------------------------
void _OnEdgeOrVertexSelected(SelectSubshapeAction selectAction)
{
if (selectAction.SelectedSubshapeType == SubshapeTypes.Edge ||
selectAction.SelectedSubshapeType == SubshapeTypes.Vertex)
{
selectAction.Stop();
Stop();
var faceRef = _TargetShape.GetSubshapeReference(_TargetBrep, _TargetFace);
if (faceRef == null)
{
Messages.Error("A subshape reference could not be produced for this face.");
Stop();
return;
}
var baseSubshapeRef = _TargetShape.GetSubshapeReference(_TargetBrep, selectAction.SelectedSubshape);
if (baseSubshapeRef == null)
{
Messages.Error("A subshape reference could not be produced for the selected edge or vertex.");
return;
}
// Calculate parameter on the edge, if any
double?edgeParam = null;
if (selectAction.SelectedSubshapeType == SubshapeTypes.Edge)
{
edgeParam = _FindEdgeParam(selectAction.SelectedSubshape.ToEdge(), selectAction);
}
// Create or update
if (_Mode == ToolMode.CreateNew)
{
// Create new
var taper = Taper.Create(_TargetBody, faceRef, baseSubshapeRef, 10.0);
if (taper != null)
{
if (edgeParam.HasValue)
{
taper.BaseParameter = edgeParam.Value;
}
InteractiveContext.Current.UndoHandler.Commit();
InteractiveContext.Current.WorkspaceController.Selection.SelectEntity(_TargetBody);
}
}
else if (_Mode == ToolMode.Reselect)
{
// Reselected face and base subshape
_TaperToChange.Face = faceRef;
_TaperToChange.BaseEdgeOrVertex = baseSubshapeRef;
if (edgeParam.HasValue)
{
_TaperToChange.BaseParameter = edgeParam.Value;
}
else
{
_TaperToChange.CalculateBaseParameter(0.5);
}
_TaperToChange.Invalidate();
InteractiveContext.Current.UndoHandler.Commit();
}
}
}
