public void CalculateWidthHeightFromCurve(PolylineCurve curve)
{
var rect = Rectangle3d.CreateFromPolyline(curve.ToPolyline());
Width = rect.Width;
Height = rect.Height;
var plane = this.Plane;
plane.Origin = rect.Corner(0);
Plane = plane;
}
protected override void onClickOculusAX(ref VREvent_t vrEvent)
{
//TODO-support projection curve
Point3d planeCenter = new Point3d();
if (!isProjection)
{
Brep[] shapes = Brep.CreatePlanarBreps(modelcurve);
modelBrep = shapes[0];
//Util.addRhinoObjectSceneNode(ref mScene, ref modelBrep, ref mesh_m, shapeType.ToString(), out renderObjSN);
UtilOld.addSceneNode(ref mScene, ref modelBrep, ref mesh_m, shapeType.ToString(), out renderObjSN);
if (shapeType == ShapeType.Circle)
{
Circle circle;
if (modelcurve.TryGetCircle(out circle))
{
planeCenter = circle.Center;
}
mScene.iPointList.Add(UtilOld.platformToVRPoint(ref mScene, UtilOld.RhinoToOpenTKPoint(circle.Center)));
mScene.iPointList.Add(UtilOld.platformToVRPoint(ref mScene, UtilOld.RhinoToOpenTKPoint(circle.PointAt(0))));
}
else if (shapeType == ShapeType.Rect)
{
Rhino.Geometry.Polyline polyline;
if (modelcurve.TryGetPolyline(out polyline))
{
Rectangle3d rect = Rectangle3d.CreateFromPolyline(polyline);
planeCenter = rect.Center;
mScene.iPointList.Add(UtilOld.platformToVRPoint(ref mScene, UtilOld.RhinoToOpenTKPoint(rect.Center)));
mScene.iPointList.Add(UtilOld.platformToVRPoint(ref mScene, UtilOld.RhinoToOpenTKPoint(rect.Corner(3))));
}
}
}
//update modelPlane and use tolerance to support unplanar surface
Plane curvePlane = new Plane();
Double tolerance = 0;
while (tolerance < 400)
{
if (modelcurve.TryGetPlane(out curvePlane, tolerance))
{
modelPlane = curvePlane;
break;
}
tolerance++;
}
int size = 240;
PlaneSurface plane_surface = new PlaneSurface(curvePlane, new Interval(-size, size), new Interval(-size, size));
Brep newPlaneBrep = Brep.CreateFromSurface(plane_surface);
Guid newPlaneID = UtilOld.addRhinoObject(ref mScene, ref newPlaneBrep, "3DP");
//might be better to use Replace(), just need to be careful about the referece count
pointOnObjRef = null;
pointOnObjRef = new ObjRef(newPlaneID);
//add icurveList since we don't use EditPoint2 for circle and rect
modelcurve.SetUserString(CurveData.CurveOnObj.ToString(), newPlaneID.ToString());
modelcurve.SetUserString(CurveData.PlaneOrigin.ToString(), curvePlane.Origin.ToString());
modelcurve.SetUserString(CurveData.PlaneNormal.ToString(), curvePlane.Normal.ToString());
mScene.iCurveList.Add(modelcurve);
//call next interaction in the chain
afterCurveCount = mScene.iCurveList.Count;
mScene.pushInteractionFromChain();
}
public override void init()
{
resetVariables();
//support undo function
if (mScene != null && (afterCurveCount - beforeCurveCount) > 0)
{
if (mScene.iCurveList[mScene.iCurveList.Count - 1].GetUserString(CurveData.CurveOnObj.ToString()) != "")
{
Guid curveOnObjId = new Guid(mScene.iCurveList[mScene.iCurveList.Count - 1].GetUserString(CurveData.CurveOnObj.ToString()));
ObjRef curveOnObjRef = new ObjRef(curveOnObjId);
if (curveOnObjRef.Object().Attributes.Name.Contains("railPlane") || curveOnObjRef.Object().Attributes.Name.Contains("MoveP"))
{
UtilOld.removeRhinoObject(ref mScene, curveOnObjRef.ObjectId);
}
}
mScene.iCurveList.RemoveAt(mScene.iCurveList.Count - 1);
UtilOld.removeSceneNode(ref mScene, ref strokeSN);
strokeSN = null;
//need to clear stroke tprint SceneNode as well here
if (renderObjSN != null)
{
UtilOld.removeSceneNode(ref mScene, ref renderObjSN);
renderObjSN = null;
}
//Util.removeRhinoObject(ref mScene, curveOnObjRef.ObjectId);
curveOnObjRef = null;
if (railPlaneSN != null)
{
UtilOld.removeRhinoObjectSceneNode(ref mScene, ref railPlaneSN);
railPlaneSN = null;
}
}
if (drawnType != DrawnType.In3D && drawnType != DrawnType.None)
{
UtilOld.showLaser(ref mScene, true);
//create and add referece planes to scene
if (drawnType == DrawnType.Reference)
{
Vector3 railPlaneNormal = UtilOld.RhinoToOpenTKVector(UtilOld.getVectorfromString(mScene.iCurveList[mScene.iCurveList.Count - 1].GetUserString(CurveData.PlaneNormal.ToString())));
OpenTK.Vector3 worldUpAxis = new Vector3(0, 0, 1);
//trick to avoid cross product of 2 parallel vetors
if (railPlaneNormal.X == 0 && railPlaneNormal.Y == 0 && railPlaneNormal.Z == 1)
{
railPlaneNormal = new Vector3(0, 0.005f, 1);
}
Plane railPlane = new Plane(mScene.iCurveList[mScene.iCurveList.Count - 1].GetBoundingBox(true).Center, UtilOld.openTkToRhinoVector(Vector3.Cross(railPlaneNormal, worldUpAxis)));
float planeSize = 240;
PlaneSurface plane_surface2 = new PlaneSurface(railPlane, new Interval(-planeSize, planeSize), new Interval(-planeSize, planeSize));
Brep railPlane2 = Brep.CreateFromSurface(plane_surface2);
Guid railPlaneGuid = UtilOld.addRhinoObjectSceneNode(ref mScene, ref railPlane2, ref railPlane_m, "railPlane", out railPlaneSN);
}
else if (drawnType == DrawnType.Plane)
{
UtilOld.setPlaneAlpha(ref mScene, 0.4f);
}
//init rayCastingObjs
Rhino.DocObjects.ObjectEnumeratorSettings settings = new Rhino.DocObjects.ObjectEnumeratorSettings();
settings.ObjectTypeFilter = Rhino.DocObjects.ObjectType.Brep;
foreach (Rhino.DocObjects.RhinoObject rhObj in mScene.rhinoDoc.Objects.GetObjectList(settings))
{
bool b1 = (drawnType == DrawnType.Plane) && rhObj.Attributes.Name.Contains("plane");
bool b2 = (drawnType == DrawnType.Surface) && (rhObj.Attributes.Name.Contains("brepMesh") || rhObj.Attributes.Name.Contains("aprint") || rhObj.Attributes.Name.Contains("patchSurface"));
bool b3 = (drawnType == DrawnType.Reference) && rhObj.Attributes.Name.Contains("railPlane");
if (b1 || b2 || b3)
{
rayCastingObjs.Add(new ObjRef(rhObj.Id));
}
}
Geometry.Geometry geo = new Geometry.DrawPointMarker(new OpenTK.Vector3(0, 0, 0));
Material.Material m = new Material.SingleColorMaterial(1, 1, 1, 0);//TODO: teseting alpha working or not
drawPoint = new SceneNode("drawPoint", ref geo, ref m);
UtilOld.addSceneNode(ref mScene, ref drawPoint);
}
else
{
UtilOld.showLaser(ref mScene, false);
}
//generate snap points when we need to draw from the center of the shapes, drawnType could be DrawnType.Reference or DrawnType.In3D
if (dynamicRender == "Extrude" || dynamicRender == "Sweep" || drawnType == DrawnType.Reference)
{
shouldSnap = true;
ShapeType shapeType = (ShapeType)mScene.selectionDic[SelectionKey.Profile1Shape];
Circle circle;
Rectangle3d rect;
if (shapeType == ShapeType.Circle)
{
if (mScene.iCurveList[mScene.iCurveList.Count - 1].TryGetCircle(out circle))
{
snapPointsList.Add(circle.Center);
}
}
else if (shapeType == ShapeType.Rect)
{
Rhino.Geometry.Polyline polyline;
if (mScene.iCurveList[mScene.iCurveList.Count - 1].TryGetPolyline(out polyline))
{
rect = Rectangle3d.CreateFromPolyline(polyline);
snapPointsList.Add(rect.Center);
}
}
//visualize the snap points
Geometry.Geometry geo = new Geometry.DrawPointMarker(new Vector3(0, 0, 0));
Material.Material m = new Material.SingleColorMaterial(0, 1, 0, 1);
UtilOld.MarkPointVR(ref mScene, UtilOld.platformToVRPoint(ref mScene, UtilOld.RhinoToOpenTKPoint(snapPointsList[0])), ref geo, ref m, out snapPointSN);
}
d = new generateModel_Delegate(generateModel);
}
private void computeContourCurve()
{
if (targetPRhObjID == Guid.Empty)
{
return;
}
ObjRef targetpObjRef = new ObjRef(targetPRhObjID);
snapPointsList = new List <Point3d>();
Double tolerance = 0;
if (drawnType != DrawnType.In3D)
{
Brep targetBrep = (Brep)(targetpObjRef.Object().Geometry);
//TODO- topLeftP won't be on the face in the 3D case. so probably use orgin
float minD = 1000000f;
int minIndex = -1;
for (int i = 0; i < targetBrep.Faces.Count; i++)
{
//cast BrepFace to Brep for ClosestPoint(P) menthod
double dist = targetBrep.Faces[i].DuplicateFace(false).ClosestPoint(projectP).DistanceTo(projectP);
if (dist < minD)
{
minD = (float)dist;
minIndex = i;
}
}
Surface s = targetBrep.Faces[minIndex];
//surface might not be a perfect planar surface
while (tolerance < toleranceMax)
{
if (s.TryGetPlane(out curvePlane, tolerance))
{
break;
}
tolerance++;
}
if (tolerance >= toleranceMax)
{
double u, v;
if (s.ClosestPoint(projectP, out u, out v))
{
Rhino.Geometry.Vector3d normal = s.NormalAt(u, v);
//TODO fix the issue when normal is inward
curvePlane = new Plane(projectP, normal);
}
}
else
{
//testing finding the edge curve
Rhino.Geometry.Curve[] edgeCurves = (targetBrep.Faces[minIndex].DuplicateFace(false)).DuplicateEdgeCurves(true);
double tol = mScene.rhinoDoc.ModelAbsoluteTolerance * 2.1;
edgeCurves = Rhino.Geometry.Curve.JoinCurves(edgeCurves, tol);
// TODO: Check if null
contourCurve = edgeCurves[0];
//detect whether it's rect or circle then generate a snap pointList
Circle circle;
Rhino.Geometry.Polyline polyline;
if (contourCurve.TryGetCircle(out circle))
{
snapPointsList.Add(circle.Center);
snapPointsList.Add(circle.PointAt(0));
snapPointsList.Add(circle.PointAt(Math.PI / 2));
snapPointsList.Add(circle.PointAt(Math.PI));
snapPointsList.Add(circle.PointAt(Math.PI * 1.5));
}
else if (contourCurve.TryGetPolyline(out polyline))
{
Rectangle3d rect = Rectangle3d.CreateFromPolyline(polyline);
snapPointsList.Add(rect.Center);
snapPointsList.Add(rect.Corner(0));
snapPointsList.Add(rect.Corner(1));
snapPointsList.Add(rect.Corner(2));
snapPointsList.Add(rect.Corner(3));
}
else
{
double u = 0;
double v = 0;
s.ClosestPoint(s.GetBoundingBox(true).Center, out u, out v);
snapPointsList.Add(s.PointAt(u, v));
}
}
}
}
