/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { GH_Colour inColor = null; GH_Colour inAmbient = null; GH_Colour inEmissive = null; GH_Number inOpacity = null; GH_Boolean inSmooth = null; String outMaterial = null; if (!DA.GetData(0, ref inColor)) { return; } if (inColor == null) { return; } DA.GetData(1, ref inAmbient); DA.GetData(2, ref inEmissive); DA.GetData(3, ref inOpacity); if (inOpacity.Value > 1 || inOpacity.Value < 0) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "The opacity input must be between 0 and 1, and has been defaulted back to 1. Check your 'O' input."); inOpacity.Value = 1.0; } DA.GetData(4, ref inSmooth); outMaterial = ConstructLambertMaterial(inColor, inAmbient, inEmissive, inOpacity.Value, inSmooth.Value); Material material = new Material(outMaterial, va3cMaterialType.Mesh); DA.SetData(0, material); }
protected override void SolveInstance(IGH_DataAccess DA) { GH_String path = new GH_String(); DA.GetData <GH_String>(0, ref path); GH_Boolean mesh = new GH_Boolean(true); if (!DA.GetData <GH_Boolean>(1, ref mesh)) { mesh = new GH_Boolean(true); } List <GH_Brep> surfaces = new List <GH_Brep>(); List <GH_String> layers = new List <GH_String>(); List <Instance> Instances = new List <Instance>(); List <GH_Curve> curves = new List <GH_Curve>(); List <GH_Mesh> meshes = new List <GH_Mesh>(); SketchUp skp = new SketchUp(); if (skp.LoadModel(path.Value, mesh.Value)) { foreach (Surface srf in skp.Surfaces) { foreach (var brep in srf.ToRhinoGeo()) { surfaces.Add(new GH_Brep(brep)); } if (srf.FaceMesh != null) { meshes.Add(new GH_Mesh(srf.FaceMesh.ToRhinoGeo())); } } foreach (Layer l in skp.Layers) { layers.Add(new GH_String(l.Name)); } foreach (Instance i in skp.Instances) { Instances.Add(i); } foreach (Edge c in skp.Edges) { curves.Add(new GH_Curve(c.ToRhinoGeo().ToNurbsCurve())); } } DA.SetDataList(0, surfaces); DA.SetDataList(1, layers); DA.SetDataList(2, Instances); DA.SetDataList(3, curves); DA.SetDataList(4, meshes); }
protected override void SolveInstance(IGH_DataAccess DA) { GH_Surface surface = new GH_Surface(); GH_String lvlbtm = new GH_String(""); GH_String style = new GH_String(""); GH_String layer = new GH_String(""); GH_Number taperAng = new GH_Number(0); GH_Number height = new GH_Number(); GH_Point stop = new GH_Point(); GH_Point sbtm = new GH_Point(); GH_Boolean structural = new GH_Boolean(true); List <Parameter> param = new List <Parameter>(); if (!DA.GetDataList <Parameter>("Parameters", param)) { param = new List <Parameter>(); } DA.GetData <GH_Surface>("Surface", ref surface); DA.GetData <GH_String>("Layer", ref layer); //DA.GetData<GH_String>("Style", ref style); DA.GetData <GH_Number>("taperAngle", ref taperAng); DA.GetData <GH_Number>("height", ref height); Slab s = new Slab(); s.FamilyOrStyle = style.Value; s.TypeOrLayer = layer.Value; s.levelbottom = lvlbtm.Value; s.structural = structural.Value; s.surface = new Profile(); s.surface.profile = new List <Loop>(); Loop loop = new Loop() { outline = new List <Component>() }; foreach (Rhino.Geometry.BrepEdge be in surface.Value.Edges) { loop.outline.Add(be.ToNurbsCurve().ToGrevitCurve()); } s.surface.profile.Add(loop); s.height = height.Value; s.parameters = param; //s.top = ComponentUtilities.GHPoint2Point(stop); //s.bottom = ComponentUtilities.GHPoint2Point(sbtm); s.slope = taperAng.Value; s.GID = this.InstanceGuid.ToString(); //SetPreview(s.GID, surface.Value); DA.SetData("GrevitComponent", s); }
protected override void SolveInstance(IGH_DataAccess DA) { GH_Program program = null; GH_Number sliderTimeGH = null; GH_Boolean isNormalized = null; if (!DA.GetData(0, ref program)) { return; } if (!DA.GetData(1, ref sliderTimeGH)) { return; } if (!DA.GetData(2, ref isNormalized)) { return; } sliderTime = (isNormalized.Value) ? sliderTimeGH.Value * program.Value.Duration : sliderTimeGH.Value; if (!form.Visible) { time = sliderTime; } program.Value.Animate(time, false); var currentTarget = program.Value.CurrentSimulationTarget; var errors = currentTarget.ProgramTargets.SelectMany(x => x.Kinematics.Errors); var meshes = currentTarget.ProgramTargets.SelectMany(x => x.Kinematics.Meshes); var joints = currentTarget.ProgramTargets.SelectMany(x => x.Kinematics.Joints); var planes = currentTarget.ProgramTargets.SelectMany(x => x.Kinematics.Planes); if (errors.Count() > 0) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Errors in solution"); } DA.SetDataList(0, meshes?.Select(x => new GH_Mesh(x))); DA.SetDataList(1, joints); DA.SetDataList(2, planes.Select(x => new GH_Plane(x))); DA.SetData(3, currentTarget.Index); DA.SetData(4, program.Value.CurrentSimulationTime); DA.SetData(5, new GH_Program(program.Value)); DA.SetDataList(6, errors); if (form.Visible && form.play.Checked.Value) { var currentTime = DateTime.Now; TimeSpan delta = currentTime - lastTime; time += delta.TotalSeconds * speed; lastTime = currentTime; this.ExpireSolution(true); } }
/*******************************************/ public static bool CastToGoo(object value, ref IGH_QuickCast target) { try { if (value is bool) { target = new GH_Boolean((bool)value); } else if (value is Color) { target = new GH_Colour((Color)value); } else if (value is Complex) { target = new GH_ComplexNumber((Complex)value); } else if (value is int) { target = new GH_Integer((int)value); } else if (value is Interval) { target = new GH_Interval((Interval)value); } else if (value is Matrix) { target = new GH_Matrix((Matrix)value); } else if (value is double || value is float) { target = new GH_Number((double)value); } else if (value is Point3d) { target = new GH_Point((Point3d)value); } else if (value is string) { target = new GH_String(value.ToString()); } else if (value is Vector3d) { target = new GH_Vector((Vector3d)value); } return(true); } catch { return(false); } }
protected override void SolveInstance(IGH_DataAccess DA) { GH_Boolean ghBolX = new GH_Boolean(); if (DA.GetData(0, ref ghBolX)) { GH_Convert.ToBoolean(ghBolX, out x, GH_Conversion.Both); //use Grasshopper to convert, these methods covers many cases and are consistent } GH_Boolean ghBolY = new GH_Boolean(); if (DA.GetData(1, ref ghBolY)) { GH_Convert.ToBoolean(ghBolY, out y, GH_Conversion.Both); } GH_Boolean ghBolZ = new GH_Boolean(); if (DA.GetData(2, ref ghBolZ)) { GH_Convert.ToBoolean(ghBolZ, out z, GH_Conversion.Both); } GH_Boolean ghBolXX = new GH_Boolean(); if (DA.GetData(3, ref ghBolXX)) { GH_Convert.ToBoolean(ghBolXX, out xx, GH_Conversion.Both); } GH_Boolean ghBolYY = new GH_Boolean(); if (DA.GetData(4, ref ghBolYY)) { GH_Convert.ToBoolean(ghBolYY, out yy, GH_Conversion.Both); } GH_Boolean ghBolZZ = new GH_Boolean(); if (DA.GetData(5, ref ghBolZZ)) { GH_Convert.ToBoolean(ghBolZZ, out zz, GH_Conversion.Both); } GsaBool6 bool6 = new GsaBool6 { X = x, Y = y, Z = z, XX = xx, YY = yy, ZZ = zz }; DA.SetData(0, new GsaBool6Goo(bool6.Duplicate())); // output as Goo-type for consistency. }
public override Boolean Equals(Object that) { if (that == null) { return(false); } if (that.GetType() != this.GetType()) { return(false); } //FIXME: use a reflection to get the Value property of the GH_Goo //if a value property is missing, it seems that we could not compare Goos (or different method should be used) // GH_Goo.Equals(GH_Goo) compare the GUIDs which are different in the common case // that's why we need to compare GH_Goo inner values // unfortunately the Value property is not generic for GH_Goo // only some GH_Goo have value assigned GH_CellState thatState = (GH_CellState)that; if (value.GetType() == GH_TypeLib.t_gh_colour) { GH_Colour thisGH_Colour = (GH_Colour)value; GH_Colour thatGH_Colour = (GH_Colour)thatState.value; return(thisGH_Colour.Value.Equals(thatGH_Colour.Value)); } else if (value.GetType() == GH_TypeLib.t_gh_bool) { GH_Boolean thisGH_Boolean = (GH_Boolean)this.value; GH_Boolean thatGH_Boolean = (GH_Boolean)thatState.value; return(thisGH_Boolean.Value.Equals(thatGH_Boolean.Value)); } else if (value.GetType() == GH_TypeLib.t_gh_int) { GH_Integer thisGH_Integer = (GH_Integer)this.value; GH_Integer thatGH_Integer = (GH_Integer)thatState.value; return(thisGH_Integer.Value.Equals(thatGH_Integer.Value)); } else if (value.GetType() == GH_TypeLib.t_gh_string) { GH_String thisGH_String = (GH_String)this.value; GH_String thatGH_String = (GH_String)thatState.value; return(thisGH_String.Value.Equals(thatGH_String.Value)); } throw new NotSupportedException("Could not compare GH_Goo type: " + value.GetType()); }
protected override void SolveInstance(IGH_DataAccess DA) { List <GH_ObjectWrapper> lines = new List <GH_ObjectWrapper>(); List <GH_Guid> cakes = new List <GH_Guid>(); GH_String layername = new GH_String(""); GH_Boolean bake = new GH_Boolean(false); DA.GetData <GH_String>("layer", ref layername); DA.GetData <GH_Boolean>("bake", ref bake); if (!DA.GetDataList <GH_ObjectWrapper>("dough", lines)) { lines = new List <GH_ObjectWrapper>(); } if (lines.Count > 0 && bake.Value) { foreach (GH_ObjectWrapper line in lines) { int layerindex = 0; Rhino.DocObjects.ObjectAttributes att = new Rhino.DocObjects.ObjectAttributes(); foreach (Rhino.DocObjects.Layer layer in Rhino.RhinoDoc.ActiveDoc.Layers) { if (layer.Name == layername.Value) { layerindex = layer.LayerIndex; } } att.LayerIndex = layerindex; Guid g = Guid.Empty; line.BakeGeometry(Rhino.RhinoDoc.ActiveDoc, att, ref g); if (g != Guid.Empty) { cakes.Add(new GH_Guid(g)); } } DA.SetDataList("cake", cakes); } }
protected override void SolveInstance(IGH_DataAccess DA) { var points = new List <GH_Point>(); var h = new GH_Number(); var k = new GH_Number(); var e = new GH_Boolean(); if (DA.GetDataList(0, points) && points == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid points list. Operation canceled."); return; } if (points.Count == 0) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Singularity point list must not be empty. Operation canceled."); return; } if (DA.GetData(1, ref h) && h == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid h value. Operation canceled."); return; } if (DA.GetData(2, ref k) && k == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid k value. Operation canceled."); return; } if (DA.GetData(3, ref e) && e == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid e value. Operation canceled."); return; } var dynamic = new GravityDynamic(); dynamic.Param["SP"] = points; dynamic.Param["h"] = h.Value; dynamic.Param["k"] = k.Value; dynamic.Param["e"] = e.Value; DA.SetData(0, new GH_ObjectWrapper(dynamic)); }
protected override void SolveInstance(IGH_DataAccess DA) { GH_Boolean assoc = new GH_Boolean(false); GH_String name = new GH_String(); GH_String layer = new GH_String(""); GH_String style = new GH_String(""); GH_String number = new GH_String(); List <Parameter> param = new List <Parameter>(); List <GH_Point> points = new List <GH_Point>(); if (!DA.GetDataList <Parameter>("Parameters", param)) { param = new List <Parameter>(); } if (!DA.GetDataList <GH_Point>("Points", points)) { points = new List <GH_Point>(); } DA.GetData <GH_String>("Name", ref name); DA.GetData <GH_Boolean>("Assoc", ref assoc); DA.GetData <GH_String>("Number", ref number); DA.GetData <GH_String>("Style", ref style); DA.GetData <GH_String>("Layer", ref layer); Room ac = new Room(name.Value, number.Value, "", param); IEnumerable <GH_Point> nodups = points.Distinct(new GH_PointComparer()); ac.points = new List <Grevit.Types.Point>(); foreach (var p in nodups) { ac.points.Add(p.ToGrevitPoint()); } ac.associative = assoc.Value; ac.FamilyOrStyle = style.Value; ac.TypeOrLayer = layer.Value; ac.GID = this.InstanceGuid.ToString(); DA.SetData("GrevitComponent", ac); }
protected override void SolveInstance(IGH_DataAccess DA) { var reset = new GH_Boolean(); if (DA.GetData(0, ref reset) && reset == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid reset input. Operation canceled."); return; } if (reset.Value) { counter = 0; } else { counter++; } DA.SetData(0, counter); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { List <Curve> _CurveList = new List <Curve>(); List <Curve> ProcessCurve = new List <Curve>(); List <Curve> _OutputCurveList = new List <Curve>(); GH_Point ReferencePoint = default(GH_Point); GH_Boolean IsReverse = default(GH_Boolean); if (!DA.GetDataList <Curve>(0, _CurveList)) { return; } if (!DA.GetData(1, ref ReferencePoint)) { return; } if (!DA.GetData(2, ref IsReverse)) { return; } ProcessCurve = _CurveList.Select(item => item.DuplicateCurve()).ToList(); for (int Index = 0; Index < ProcessCurve.Count; Index++) { Curve CrvItem = _CurveList[Index]; if (CrvItem.PointAtStart.DistanceTo(ReferencePoint.Value) > CrvItem.PointAtEnd.DistanceTo(ReferencePoint.Value)) { CrvItem.Reverse(); } if (IsReverse.Value) { CrvItem.Reverse(); } _OutputCurveList.Add(CrvItem); } DA.SetDataList(0, _OutputCurveList); }
protected override void SolveInstance(IGH_DataAccess DA) { GH_Curve baseline = new GH_Curve(); GH_String level = new GH_String("none"); GH_Number height = new GH_Number(); GH_Number offset = new GH_Number(); GH_Boolean join = new GH_Boolean(true); GH_Boolean flip = new GH_Boolean(false); GH_String family = new GH_String(""); GH_String type = new GH_String("none"); List<Parameter> parameters = new List<Parameter>(); if (!DA.GetDataList<Parameter>("Parameters", parameters)) parameters = new List<Parameter>(); DA.GetData<GH_Boolean>("Join", ref join); DA.GetData<GH_String>("Type", ref type); DA.GetData<GH_String>("Levelbottom", ref level); DA.GetData<GH_Number>("Height", ref height); DA.GetData<GH_Curve>("Baseline", ref baseline); DA.GetData<GH_Boolean>("Flip", ref flip); Wall wall = new Wall(family.Value, type.Value, parameters, baseline.ToGrevitCurve(), level.Value,height.Value,join.Value,flip.Value ); Rhino.Geometry.Surface srf = Rhino.Geometry.Surface.CreateExtrusion(baseline.Value, new Rhino.Geometry.Vector3d(0, 0, height.Value)); SetGID(wall); SetPreview(wall.GID, srf.ToBrep()); DA.SetData("GrevitComponent", wall); }
protected override void SolveInstance(IGH_DataAccess DA) { GH_Curve line = new GH_Curve(); DA.GetData<GH_Curve>("Curve", ref line); GH_Boolean isModelLine = new GH_Boolean(false); GH_Boolean isDetailLine = new GH_Boolean(false); GH_Boolean isRoomBoundary = new GH_Boolean(false); DA.GetData<GH_Boolean>("isModelLine", ref isModelLine); DA.GetData<GH_Boolean>("isDetailLine", ref isDetailLine); DA.GetData<GH_Boolean>("isRoomBoundary", ref isRoomBoundary); RevitLine revitLine = new RevitLine(); revitLine.curve = line.Value.ToNurbsCurve().ToGrevitCurve(); SetGID(revitLine); revitLine.isModelCurve = isModelLine.Value; revitLine.isDetailCurve = isDetailLine.Value; revitLine.isRoomBounding = isRoomBoundary.Value; DA.SetData("GrevitComponent", revitLine); }
protected override void SolveInstance(IGH_DataAccess DA) { GH_String name = new GH_String(); GH_Number elevation = new GH_Number(); GH_Boolean view = new GH_Boolean(); DA.GetData<GH_String>("Name", ref name); DA.GetData<GH_Boolean>("View", ref view); DA.GetData<GH_Number>("Elevation", ref elevation); Level level = new Level(name.Value, elevation.Value, view.Value); level.GID = this.InstanceGuid.ToString(); DA.SetData("GrevitComponent", level); }
protected override void SolveInstance(IGH_DataAccess DA) { string serializedData = this.GetValue("assembly", ""); if (serializedData != "") { this.assembly = (Types.Assembly)Serialization.Utilities.Deserialize(serializedData, typeof(Types.Assembly)); } GH_String path = new GH_String(""); DA.GetData<GH_String>("Path", ref path); GH_Boolean percentual = new GH_Boolean(false); if (!DA.GetData<GH_Boolean>("Percentual", ref percentual)) percentual.Value = false; this.isPercentual = percentual.Value; this.alternativeDataSourcePath = path.Value; //if (assembly != null) this.SetValue("assembly", Serialization.Utilities.Serialize(this.assembly)); DA.SetData("Material", assembly); }
/*******************************************/ public static bool CastToGoo(object value, ref GH_Boolean target) { return(GH_Convert.ToGHBoolean(value, GH_Conversion.Both, ref target)); }
protected override void SolveInstance(IGH_DataAccess DA) { var respawn = new GH_Boolean(); var newSpawn = new GH_Integer(); var rndSpawn = new GH_Integer(); var avgRadius = new GH_Number(); var bounds = new GH_Brep(); var snapTol = new GH_Number(); var snapAngle = new GH_Number(); var surface = new GH_Surface(); var lineCont = new GH_Boolean(); if (DA.GetData(0, ref respawn) && respawn == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid respawn value. Operation canceled."); return; } if (DA.GetData(1, ref newSpawn) && newSpawn == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid new spawn value. Operation canceled."); return; } if (DA.GetData(2, ref rndSpawn) && rndSpawn == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid new spawn randomizing value. Operation canceled."); return; } if (DA.GetData(3, ref avgRadius) && avgRadius == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid interpolation radius value. Operation canceled."); return; } if (DA.GetData(4, ref bounds) && bounds == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid bounding box. Operation canceled."); return; } if (DA.GetData(5, ref snapTol) && snapTol == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid snap tolerance. Operation canceled."); return; } if (DA.GetData(6, ref snapAngle) && snapAngle == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid snapping angle. Operation canceled."); return; } if (DA.GetData(7, ref surface) && surface == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid surface constraint. Operation canceled."); return; } if (DA.GetData(8, ref lineCont) && lineCont == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid line continuity value. Operation canceled."); return; } DynamicSettings settings = new DynamicSettings(); settings.respawn = respawn.Value; settings.newSpawn = newSpawn.Value; settings.rndSpawn = rndSpawn.Value; settings.avgRadius = avgRadius.Value; settings.bounds = bounds; settings.snapTol = snapTol.Value; settings.snapAngle = snapAngle.Value; settings.surface = surface; settings.lineCont = lineCont.Value; var output = new GH_ObjectWrapper(settings); DA.SetData(0, output); }
public static Response Grasshopper(NancyContext ctx) { // load grasshopper file var archive = new GH_Archive(); // TODO: stream to string var body = ctx.Request.Body.ToString(); string json = string.Empty; using (var reader = new StreamReader(ctx.Request.Body)) { json = reader.ReadToEnd(); } //GrasshopperInput input = Newtonsoft.Json.JsonConvert.DeserializeObject<GrasshopperInput>(json); //JsonSerializerSettings settings = new JsonSerializerSettings(); //settings.ContractResolver = new DictionaryAsArrayResolver(); Schema input = JsonConvert.DeserializeObject <Schema>(json); string grasshopperXml = string.Empty; if (input.Algo != null) { // If request contains markup byte[] byteArray = Convert.FromBase64String(input.Algo); grasshopperXml = System.Text.Encoding.UTF8.GetString(byteArray); } else { // If request contains pointer string pointer = input.Pointer; grasshopperXml = GetGhxFromPointer(pointer); } if (!archive.Deserialize_Xml(grasshopperXml)) { throw new Exception(); } var definition = new GH_Document(); if (!archive.ExtractObject(definition, "Definition")) { throw new Exception(); } // Set input params foreach (var obj in definition.Objects) { var group = obj as GH_Group; if (group == null) { continue; } if (group.NickName.Contains("RH_IN")) { // It is a RestHopper input group! GHTypeCodes code = (GHTypeCodes)Int32.Parse(group.NickName.Split(':')[1]); var param = group.Objects()[0]; //GH_Param<IGH_Goo> goo = obj as GH_Param<IGH_Goo>; // SetData foreach (Resthopper.IO.DataTree <ResthopperObject> tree in input.Values) { string paramname = tree.ParamName; if (group.NickName == paramname) { switch (code) { case GHTypeCodes.Boolean: //PopulateParam<GH_Boolean>(goo, tree); Param_Boolean boolParam = param as Param_Boolean; foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); List <GH_Boolean> objectList = new List <GH_Boolean>(); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; bool boolean = JsonConvert.DeserializeObject <bool>(restobj.Data); GH_Boolean data = new GH_Boolean(boolean); boolParam.AddVolatileData(path, i, data); } } break; case GHTypeCodes.Point: //PopulateParam<GH_Point>(goo, tree); Param_Point ptParam = param as Param_Point; foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); List <GH_Point> objectList = new List <GH_Point>(); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Point3d rPt = JsonConvert.DeserializeObject <Rhino.Geometry.Point3d>(restobj.Data); GH_Point data = new GH_Point(rPt); ptParam.AddVolatileData(path, i, data); } } break; case GHTypeCodes.Vector: //PopulateParam<GH_Vector>(goo, tree); Param_Vector vectorParam = param as Param_Vector; foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); List <GH_Vector> objectList = new List <GH_Vector>(); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Vector3d rhVector = JsonConvert.DeserializeObject <Rhino.Geometry.Vector3d>(restobj.Data); GH_Vector data = new GH_Vector(rhVector); vectorParam.AddVolatileData(path, i, data); } } break; case GHTypeCodes.Integer: //PopulateParam<GH_Integer>(goo, tree); Param_Integer integerParam = param as Param_Integer; foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); List <GH_Integer> objectList = new List <GH_Integer>(); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; int rhinoInt = JsonConvert.DeserializeObject <int>(restobj.Data); GH_Integer data = new GH_Integer(rhinoInt); integerParam.AddVolatileData(path, i, data); } } break; case GHTypeCodes.Number: //PopulateParam<GH_Number>(goo, tree); Param_Number numberParam = param as Param_Number; foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); List <GH_Number> objectList = new List <GH_Number>(); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; double rhNumber = JsonConvert.DeserializeObject <double>(restobj.Data); GH_Number data = new GH_Number(rhNumber); numberParam.AddVolatileData(path, i, data); } } break; case GHTypeCodes.Text: //PopulateParam<GH_String>(goo, tree); Param_String stringParam = param as Param_String; foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); List <GH_String> objectList = new List <GH_String>(); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; string rhString = JsonConvert.DeserializeObject <string>(restobj.Data); GH_String data = new GH_String(rhString); stringParam.AddVolatileData(path, i, data); } } break; case GHTypeCodes.Line: //PopulateParam<GH_Line>(goo, tree); Param_Line lineParam = param as Param_Line; foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); List <GH_Line> objectList = new List <GH_Line>(); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Line rhLine = JsonConvert.DeserializeObject <Rhino.Geometry.Line>(restobj.Data); GH_Line data = new GH_Line(rhLine); lineParam.AddVolatileData(path, i, data); } } break; case GHTypeCodes.Curve: //PopulateParam<GH_Curve>(goo, tree); Param_Curve curveParam = param as Param_Curve; foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); List <GH_Curve> objectList = new List <GH_Curve>(); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; GH_Curve ghCurve; try { Rhino.Geometry.Polyline data = JsonConvert.DeserializeObject <Rhino.Geometry.Polyline>(restobj.Data); Rhino.Geometry.Curve c = new Rhino.Geometry.PolylineCurve(data); ghCurve = new GH_Curve(c); } catch { Rhino.Geometry.NurbsCurve data = JsonConvert.DeserializeObject <Rhino.Geometry.NurbsCurve>(restobj.Data); Rhino.Geometry.Curve c = new Rhino.Geometry.NurbsCurve(data); ghCurve = new GH_Curve(c); } curveParam.AddVolatileData(path, i, ghCurve); } } break; case GHTypeCodes.Circle: //PopulateParam<GH_Circle>(goo, tree); Param_Circle circleParam = param as Param_Circle; foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); List <GH_Circle> objectList = new List <GH_Circle>(); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Circle rhCircle = JsonConvert.DeserializeObject <Rhino.Geometry.Circle>(restobj.Data); GH_Circle data = new GH_Circle(rhCircle); circleParam.AddVolatileData(path, i, data); } } break; case GHTypeCodes.PLane: //PopulateParam<GH_Plane>(goo, tree); Param_Plane planeParam = param as Param_Plane; foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); List <GH_Plane> objectList = new List <GH_Plane>(); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Plane rhPlane = JsonConvert.DeserializeObject <Rhino.Geometry.Plane>(restobj.Data); GH_Plane data = new GH_Plane(rhPlane); planeParam.AddVolatileData(path, i, data); } } break; case GHTypeCodes.Rectangle: //PopulateParam<GH_Rectangle>(goo, tree); Param_Rectangle rectangleParam = param as Param_Rectangle; foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); List <GH_Rectangle> objectList = new List <GH_Rectangle>(); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Rectangle3d rhRectangle = JsonConvert.DeserializeObject <Rhino.Geometry.Rectangle3d>(restobj.Data); GH_Rectangle data = new GH_Rectangle(rhRectangle); rectangleParam.AddVolatileData(path, i, data); } } break; case GHTypeCodes.Box: //PopulateParam<GH_Box>(goo, tree); Param_Box boxParam = param as Param_Box; foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); List <GH_Box> objectList = new List <GH_Box>(); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Box rhBox = JsonConvert.DeserializeObject <Rhino.Geometry.Box>(restobj.Data); GH_Box data = new GH_Box(rhBox); boxParam.AddVolatileData(path, i, data); } } break; case GHTypeCodes.Surface: //PopulateParam<GH_Surface>(goo, tree); Param_Surface surfaceParam = param as Param_Surface; foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); List <GH_Surface> objectList = new List <GH_Surface>(); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Surface rhSurface = JsonConvert.DeserializeObject <Rhino.Geometry.Surface>(restobj.Data); GH_Surface data = new GH_Surface(rhSurface); surfaceParam.AddVolatileData(path, i, data); } } break; case GHTypeCodes.Brep: //PopulateParam<GH_Brep>(goo, tree); Param_Brep brepParam = param as Param_Brep; foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); List <GH_Brep> objectList = new List <GH_Brep>(); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Brep rhBrep = JsonConvert.DeserializeObject <Rhino.Geometry.Brep>(restobj.Data); GH_Brep data = new GH_Brep(rhBrep); brepParam.AddVolatileData(path, i, data); } } break; case GHTypeCodes.Mesh: //PopulateParam<GH_Mesh>(goo, tree); Param_Mesh meshParam = param as Param_Mesh; foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); List <GH_Mesh> objectList = new List <GH_Mesh>(); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Mesh rhMesh = JsonConvert.DeserializeObject <Rhino.Geometry.Mesh>(restobj.Data); GH_Mesh data = new GH_Mesh(rhMesh); meshParam.AddVolatileData(path, i, data); } } break; case GHTypeCodes.Slider: //PopulateParam<GH_Number>(goo, tree); GH_NumberSlider sliderParam = param as GH_NumberSlider; foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); List <GH_Number> objectList = new List <GH_Number>(); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; double rhNumber = JsonConvert.DeserializeObject <double>(restobj.Data); GH_Number data = new GH_Number(rhNumber); sliderParam.AddVolatileData(path, i, data); } } break; case GHTypeCodes.BooleanToggle: //PopulateParam<GH_Boolean>(goo, tree); GH_BooleanToggle toggleParam = param as GH_BooleanToggle; foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); List <GH_Boolean> objectList = new List <GH_Boolean>(); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; bool rhBoolean = JsonConvert.DeserializeObject <bool>(restobj.Data); GH_Boolean data = new GH_Boolean(rhBoolean); toggleParam.AddVolatileData(path, i, data); } } break; case GHTypeCodes.Panel: //PopulateParam<GH_String>(goo, tree); GH_Panel panelParam = param as GH_Panel; foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); List <GH_Panel> objectList = new List <GH_Panel>(); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; string rhString = JsonConvert.DeserializeObject <string>(restobj.Data); GH_String data = new GH_String(rhString); panelParam.AddVolatileData(path, i, data); } } break; } } } } } Schema OutputSchema = new Schema(); OutputSchema.Algo = Utils.Base64Encode(string.Empty); // Parse output params foreach (var obj in definition.Objects) { var group = obj as GH_Group; if (group == null) { continue; } if (group.NickName.Contains("RH_OUT")) { // It is a RestHopper output group! GHTypeCodes code = (GHTypeCodes)Int32.Parse(group.NickName.Split(':')[1]); var param = group.Objects()[0] as IGH_Param; if (param == null) { continue; } try { param.CollectData(); param.ComputeData(); } catch (Exception) { param.Phase = GH_SolutionPhase.Failed; // TODO: throw something better throw; } // Get data Resthopper.IO.DataTree <ResthopperObject> OutputTree = new Resthopper.IO.DataTree <ResthopperObject>(); OutputTree.ParamName = group.NickName; var volatileData = param.VolatileData; for (int p = 0; p < volatileData.PathCount; p++) { List <ResthopperObject> ResthopperObjectList = new List <ResthopperObject>(); foreach (var goo in volatileData.get_Branch(p)) { if (goo == null) { continue; } else if (goo.GetType() == typeof(GH_Boolean)) { GH_Boolean ghValue = goo as GH_Boolean; bool rhValue = ghValue.Value; ResthopperObjectList.Add(GetResthopperObject <bool>(rhValue)); } else if (goo.GetType() == typeof(GH_Point)) { GH_Point ghValue = goo as GH_Point; Point3d rhValue = ghValue.Value; ResthopperObjectList.Add(GetResthopperObject <Point3d>(rhValue)); } else if (goo.GetType() == typeof(GH_Vector)) { GH_Vector ghValue = goo as GH_Vector; Vector3d rhValue = ghValue.Value; ResthopperObjectList.Add(GetResthopperObject <Vector3d>(rhValue)); } else if (goo.GetType() == typeof(GH_Integer)) { GH_Integer ghValue = goo as GH_Integer; int rhValue = ghValue.Value; ResthopperObjectList.Add(GetResthopperObject <int>(rhValue)); } else if (goo.GetType() == typeof(GH_Number)) { GH_Number ghValue = goo as GH_Number; double rhValue = ghValue.Value; ResthopperObjectList.Add(GetResthopperObject <double>(rhValue)); } else if (goo.GetType() == typeof(GH_String)) { GH_String ghValue = goo as GH_String; string rhValue = ghValue.Value; ResthopperObjectList.Add(GetResthopperObject <string>(rhValue)); } else if (goo.GetType() == typeof(GH_Line)) { GH_Line ghValue = goo as GH_Line; Line rhValue = ghValue.Value; ResthopperObjectList.Add(GetResthopperObject <Line>(rhValue)); } else if (goo.GetType() == typeof(GH_Curve)) { GH_Curve ghValue = goo as GH_Curve; Curve rhValue = ghValue.Value; ResthopperObjectList.Add(GetResthopperObject <Curve>(rhValue)); } else if (goo.GetType() == typeof(GH_Circle)) { GH_Circle ghValue = goo as GH_Circle; Circle rhValue = ghValue.Value; ResthopperObjectList.Add(GetResthopperObject <Circle>(rhValue)); } else if (goo.GetType() == typeof(GH_Plane)) { GH_Plane ghValue = goo as GH_Plane; Plane rhValue = ghValue.Value; ResthopperObjectList.Add(GetResthopperObject <Plane>(rhValue)); } else if (goo.GetType() == typeof(GH_Rectangle)) { GH_Rectangle ghValue = goo as GH_Rectangle; Rectangle3d rhValue = ghValue.Value; ResthopperObjectList.Add(GetResthopperObject <Rectangle3d>(rhValue)); } else if (goo.GetType() == typeof(GH_Box)) { GH_Box ghValue = goo as GH_Box; Box rhValue = ghValue.Value; ResthopperObjectList.Add(GetResthopperObject <Box>(rhValue)); } else if (goo.GetType() == typeof(GH_Surface)) { GH_Surface ghValue = goo as GH_Surface; Brep rhValue = ghValue.Value; ResthopperObjectList.Add(GetResthopperObject <Brep>(rhValue)); } else if (goo.GetType() == typeof(GH_Brep)) { GH_Brep ghValue = goo as GH_Brep; Brep rhValue = ghValue.Value; ResthopperObjectList.Add(GetResthopperObject <Brep>(rhValue)); } else if (goo.GetType() == typeof(GH_Mesh)) { GH_Mesh ghValue = goo as GH_Mesh; Mesh rhValue = ghValue.Value; ResthopperObjectList.Add(GetResthopperObject <Mesh>(rhValue)); } } GhPath path = new GhPath(new int[] { p }); OutputTree.Add(path.ToString(), ResthopperObjectList); } OutputSchema.Values.Add(OutputTree); } } if (OutputSchema.Values.Count < 1) { throw new System.Exceptions.PayAttentionException("Looks like you've missed something..."); // TODO } string returnJson = JsonConvert.SerializeObject(OutputSchema); return(returnJson); }
protected override void SolveInstance(IGH_DataAccess DA) { GsaBeamLoad beamLoad = new GsaBeamLoad(); // 0 Load case int lc = 1; GH_Integer gh_lc = new GH_Integer(); if (DA.GetData(0, ref gh_lc)) { GH_Convert.ToInt32(gh_lc, out lc, GH_Conversion.Both); } beamLoad.BeamLoad.Case = lc; // 1 element/beam list string beamList = ""; //pick an initial name that is sure not to be used... GH_String gh_bl = new GH_String(); if (DA.GetData(1, ref gh_bl)) { GH_Convert.ToString(gh_bl, out beamList, GH_Conversion.Both); } //var isNumeric = int.TryParse(beamList, out int n); //if (isNumeric) // beamList = "PB" + n; beamLoad.BeamLoad.Elements = beamList; // 2 Name string name = ""; GH_String gh_name = new GH_String(); if (DA.GetData(2, ref gh_name)) { if (GH_Convert.ToString(gh_name, out name, GH_Conversion.Both)) { beamLoad.BeamLoad.Name = name; } } // 3 axis int axis = 0; beamLoad.BeamLoad.AxisProperty = 0; //Note there is currently a bug/undocumented in GsaAPI that cannot translate an integer into axis type (Global, Local or edformed local) GH_Integer gh_ax = new GH_Integer(); if (DA.GetData(3, ref gh_ax)) { GH_Convert.ToInt32(gh_ax, out axis, GH_Conversion.Both); if (axis == 0 || axis == -1) { beamLoad.BeamLoad.AxisProperty = axis; } } // 4 direction string dir = "Z"; Direction direc = Direction.Z; GH_String gh_dir = new GH_String(); if (DA.GetData(4, ref gh_dir)) { GH_Convert.ToString(gh_dir, out dir, GH_Conversion.Both); } dir = dir.ToUpper().Trim(); if (dir == "X") { direc = Direction.X; } if (dir == "Y") { direc = Direction.Y; } if (dir == "XX") { direc = Direction.XX; } if (dir == "YY") { direc = Direction.YY; } if (dir == "ZZ") { direc = Direction.ZZ; } beamLoad.BeamLoad.Direction = direc; // 5 projection bool prj = false; GH_Boolean gh_prj = new GH_Boolean(); if (DA.GetData(5, ref gh_prj)) { GH_Convert.ToBoolean(gh_prj, out prj, GH_Conversion.Both); } beamLoad.BeamLoad.IsProjected = prj; // 6 value (1) double load1 = 0; if (DA.GetData(6, ref load1)) { if (direc == Direction.Z) { load1 *= -1000; //convert to kN } else { load1 *= 1000; } } switch (_mode) { case FoldMode.Point: if (_mode == FoldMode.Point) { beamLoad.BeamLoad.Type = BeamLoadType.POINT; // 7 pos (1) double pos = 0; if (DA.GetData(7, ref pos)) { pos *= -1; } // set position and value beamLoad.BeamLoad.SetValue(0, load1); beamLoad.BeamLoad.SetPosition(0, pos); } break; case FoldMode.Uniform: if (_mode == FoldMode.Uniform) { beamLoad.BeamLoad.Type = BeamLoadType.UNIFORM; // set value beamLoad.BeamLoad.SetValue(0, load1); } break; case FoldMode.Linear: if (_mode == FoldMode.Linear) { beamLoad.BeamLoad.Type = BeamLoadType.LINEAR; // 6 value (2) double load2 = 0; if (DA.GetData(7, ref load2)) { if (direc == Direction.Z) { load2 *= -1000; //convert to kN } else { load2 *= 1000; } } // set value beamLoad.BeamLoad.SetValue(0, load1); beamLoad.BeamLoad.SetValue(1, load2); } break; case FoldMode.Patch: if (_mode == FoldMode.Patch) { beamLoad.BeamLoad.Type = BeamLoadType.PATCH; // 7 pos (1) double pos1 = 0; if (DA.GetData(7, ref pos1)) { pos1 *= -1; } // 9 pos (2) double pos2 = 1; if (DA.GetData(9, ref pos2)) { pos2 *= -1; } // 8 value (2) double load2 = 0; if (DA.GetData(8, ref load2)) { if (direc == Direction.Z) { load2 *= -1000; //convert to kN } else { load2 *= 1000; } } // set value beamLoad.BeamLoad.SetValue(0, load1); beamLoad.BeamLoad.SetValue(1, load2); beamLoad.BeamLoad.SetPosition(0, pos1); beamLoad.BeamLoad.SetPosition(1, pos2); } break; case FoldMode.Trilinear: if (_mode == FoldMode.Trilinear) { beamLoad.BeamLoad.Type = BeamLoadType.TRILINEAR; // 7 pos (1) double pos1 = 0; if (DA.GetData(7, ref pos1)) { pos1 *= -1; } // 9 pos (2) double pos2 = 1; if (DA.GetData(9, ref pos2)) { pos2 *= -1; } // 8 value (2) double load2 = 0; if (DA.GetData(8, ref load2)) { if (direc == Direction.Z) { load2 *= -1000; //convert to kN } else { load2 *= 1000; } } // set value beamLoad.BeamLoad.SetValue(0, load1); beamLoad.BeamLoad.SetValue(1, load2); beamLoad.BeamLoad.SetPosition(0, pos1); beamLoad.BeamLoad.SetPosition(1, pos2); } break; default: throw new ArgumentOutOfRangeException(); } GsaLoad gsaLoad = new GsaLoad(beamLoad); DA.SetData(0, new GsaLoadGoo(gsaLoad)); }
/// <summary> /// Attempt a cast from generic object. /// </summary> /// <param name="source"> Reference to source of cast. </param> /// <returns> True on success, false on failure. </returns> public override bool CastFrom(object source) { if (source == null) { return(false); } //Cast from Linear Configuration Control if (typeof(LinearConfigurationControl).IsAssignableFrom(source.GetType())) { Value = source as LinearConfigurationControl; return(true); } //Cast from Boolean if (typeof(GH_Boolean).IsAssignableFrom(source.GetType())) { GH_Boolean ghBoolean = source as GH_Boolean; Value = new LinearConfigurationControl(ghBoolean.Value); return(true); } //Cast from Action if (typeof(Action).IsAssignableFrom(source.GetType())) { if (source is LinearConfigurationControl action) { Value = action; return(true); } } //Cast from Action Goo if (typeof(GH_Action).IsAssignableFrom(source.GetType())) { GH_Action actionGoo = source as GH_Action; if (actionGoo.Value is LinearConfigurationControl action) { Value = action; return(true); } } //Cast from Instruction if (typeof(IInstruction).IsAssignableFrom(source.GetType())) { if (source is LinearConfigurationControl instruction) { Value = instruction; return(true); } } //Cast from Instruction Goo if (typeof(GH_Instruction).IsAssignableFrom(source.GetType())) { GH_Instruction instructionGoo = source as GH_Instruction; if (instructionGoo.Value is LinearConfigurationControl instruction) { Value = instruction; return(true); } } return(false); }
protected override void SolveInstance(IGH_DataAccess DA) { GsaFaceLoad faceLoad = new GsaFaceLoad(); // 0 Load case int lc = 1; GH_Integer gh_lc = new GH_Integer(); if (DA.GetData(0, ref gh_lc)) { GH_Convert.ToInt32(gh_lc, out lc, GH_Conversion.Both); } faceLoad.FaceLoad.Case = lc; // 1 element/beam list string elemList = ""; GH_String gh_el = new GH_String(); if (DA.GetData(1, ref gh_el)) { GH_Convert.ToString(gh_el, out elemList, GH_Conversion.Both); } //var isNumeric = int.TryParse(elemList, out int n); //if (isNumeric) // elemList = "PA" + n; faceLoad.FaceLoad.Elements = elemList; // 2 Name string name = ""; GH_String gh_name = new GH_String(); if (DA.GetData(2, ref gh_name)) { if (GH_Convert.ToString(gh_name, out name, GH_Conversion.Both)) { faceLoad.FaceLoad.Name = name; } } // 3 axis int axis = -1; faceLoad.FaceLoad.AxisProperty = 0; //Note there is currently a bug/undocumented in GsaAPI that cannot translate an integer into axis type (Global, Local or edformed local) GH_Integer gh_ax = new GH_Integer(); if (DA.GetData(3, ref gh_ax)) { GH_Convert.ToInt32(gh_ax, out axis, GH_Conversion.Both); if (axis == 0 || axis == -1) { faceLoad.FaceLoad.AxisProperty = axis; } } // 4 direction string dir = "Z"; Direction direc = Direction.Z; GH_String gh_dir = new GH_String(); if (DA.GetData(4, ref gh_dir)) { GH_Convert.ToString(gh_dir, out dir, GH_Conversion.Both); } dir = dir.ToUpper().Trim(); if (dir == "X") { direc = Direction.X; } if (dir == "Y") { direc = Direction.Y; } faceLoad.FaceLoad.Direction = direc; switch (_mode) { case FoldMode.Uniform: if (_mode == FoldMode.Uniform) { faceLoad.FaceLoad.Type = FaceLoadType.CONSTANT; //projection bool prj = false; GH_Boolean gh_prj = new GH_Boolean(); if (DA.GetData(5, ref gh_prj)) { GH_Convert.ToBoolean(gh_prj, out prj, GH_Conversion.Both); } faceLoad.FaceLoad.IsProjected = prj; double load1 = 0; if (DA.GetData(6, ref load1)) { if (direc == Direction.Z) { load1 *= -1000; //convert to kN } else { load1 *= 1000; } } // set position and value faceLoad.FaceLoad.SetValue(0, load1); } break; case FoldMode.Variable: if (_mode == FoldMode.Variable) { faceLoad.FaceLoad.Type = FaceLoadType.GENERAL; //projection bool prj = false; GH_Boolean gh_prj = new GH_Boolean(); if (DA.GetData(5, ref gh_prj)) { GH_Convert.ToBoolean(gh_prj, out prj, GH_Conversion.Both); } faceLoad.FaceLoad.IsProjected = prj; double load1 = 0; if (DA.GetData(6, ref load1)) { if (direc == Direction.Z) { load1 *= -1000; //convert to kN } else { load1 *= 1000; } } double load2 = 0; if (DA.GetData(7, ref load2)) { if (direc == Direction.Z) { load2 *= -1000; //convert to kN } else { load2 *= 1000; } } double load3 = 0; if (DA.GetData(8, ref load3)) { if (direc == Direction.Z) { load3 *= -1000; //convert to kN } else { load3 *= 1000; } } double load4 = 0; if (DA.GetData(9, ref load4)) { if (direc == Direction.Z) { load4 *= -1000; //convert to kN } else { load4 *= 1000; } } // set value faceLoad.FaceLoad.SetValue(0, load1); faceLoad.FaceLoad.SetValue(1, load2); faceLoad.FaceLoad.SetValue(2, load3); faceLoad.FaceLoad.SetValue(3, load4); } break; case FoldMode.Point: if (_mode == FoldMode.Point) { faceLoad.FaceLoad.Type = FaceLoadType.POINT; //projection bool prj = false; GH_Boolean gh_prj = new GH_Boolean(); if (DA.GetData(5, ref gh_prj)) { GH_Convert.ToBoolean(gh_prj, out prj, GH_Conversion.Both); } faceLoad.FaceLoad.IsProjected = prj; double load1 = 0; if (DA.GetData(6, ref load1)) { if (direc == Direction.Z) { load1 *= -1000; //convert to kN } else { load1 *= 1000; } } double r = 0; DA.GetData(7, ref r); double s = 0; DA.GetData(8, ref s); // set position and value faceLoad.FaceLoad.SetValue(0, load1); //faceLoad.Position.X = r; //note Vector2 currently only get in GsaAPI //faceLoad.Position.Y = s; } break; case FoldMode.Edge: if (_mode == FoldMode.Edge) { //faceLoad.Type = BeamLoadType.EDGE; GsaAPI implementation missing // get data int edge = 1; DA.GetData(5, ref edge); double load1 = 0; if (DA.GetData(6, ref load1)) { if (direc == Direction.Z) { load1 *= -1000; //convert to kN } else { load1 *= 1000; } } double load2 = 0; if (DA.GetData(7, ref load2)) { if (direc == Direction.Z) { load2 *= -1000; //convert to kN } else { load2 *= 1000; } } // set value faceLoad.FaceLoad.SetValue(0, load1); faceLoad.FaceLoad.SetValue(1, load2); //faceLoad.Edge = edge; //note implementation of edge-load is not yet supported in GsaAPI faceLoad = null; } break; default: throw new ArgumentOutOfRangeException(); } GsaLoad gsaLoad = new GsaLoad(faceLoad); DA.SetData(0, new GsaLoadGoo(gsaLoad)); }
protected override void SolveInstance(IGH_DataAccess DA) { this.Components = new List <object>(); DA.GetDataList <object>("Components", this.Components); GH_Boolean update = new GH_Boolean(true); GH_Boolean erase = new GH_Boolean(false); this.Ip = new GH_String("127.0.0.1"); this.Port = new GH_Integer(8002); this.Timeout = new GH_Integer(10000); DA.GetData <GH_Boolean>("Update", ref update); DA.GetData <GH_String>("IP", ref this.Ip); DA.GetData <GH_Integer>("Port", ref this.Port); DA.GetData <GH_Integer>("TimeOut", ref this.Timeout); GH_Boolean send = new GH_Boolean(); DA.GetData <GH_Boolean>("Send", ref send); DA.GetData <GH_Boolean>("Erase", ref erase); this.Erase = erase.Value; this.Update = update.Value; GH_Number scale = new GH_Number(3.28084); DA.GetData <GH_Number>("Scale", ref scale); this.Scale = scale.Value; if (send.Value) { this.Icon = Properties.Resources.paper_airplane_red; this.DestroyIconCache(); Grasshopper.Instances.RedrawAll(); bool retry = true; string responseData = ""; try { while (retry) { using (TcpClient tcpClient = new TcpClient()) { tcpClient.Connect(IPAddress.Parse(Ip.Value), Port.Value); tcpClient.NoDelay = true; tcpClient.ReceiveTimeout = Timeout.Value; tcpClient.SendTimeout = Timeout.Value; using (NetworkStream stream = tcpClient.GetStream()) { using (StreamWriter writer = new StreamWriter(stream, new UTF8Encoding(false))) { writer.AutoFlush = true; using (StreamReader reader = new StreamReader(stream)) { string line = ComponentsToString(this.Components); writer.WriteLine(line); string response = reader.ReadLine(); if (response == line) { retry = false; } responseData = reader.ReadLine(); } } } } } } catch (Exception ex) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, ex.Message); } try { if (responseData != "") { revitFamilyCollection = (RevitFamilyCollection)Grevit.Serialization.Utilities.Deserialize(responseData, typeof(RevitFamilyCollection)); } } catch (Exception ex) { } this.Icon = Properties.Resources.paper_airplane_green; this.DestroyIconCache(); Grasshopper.Instances.RedrawAll(); } DA.SetDataList("Categories", revitFamilyCollection.Categories); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { var props = new ArchivableDictionary(); for (int i = 0; i < Params.Input.Count; i++) { var key = Params.Input[i].NickName; object value = null; DA.GetData(i, ref value); if (value != null) { GH_Number nmb = value as GH_Number; if (nmb != null) { props.Set(key, nmb.Value); } if (value is double) { props.Set(key, (double)value); } if (value is int) { props.Set(key, (double)value); } GH_String str = value as GH_String; if (str != null) { props.Set(key, str.Value); } if (value is string) { props.Set(key, (string)value); } GH_Boolean bol = value as GH_Boolean; if (bol != null) { props.Set(key, bol.Value); } GH_ObjectWrapper temp = value as GH_ObjectWrapper; if (temp != null) { ArchivableDictionary dict = ((GH_ObjectWrapper)value).Value as ArchivableDictionary; if (dict != null) { props.Set(key, dict); } } if (!props.ContainsKey(key)) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, key + " could not be set. Strings, numbers, booleans and ArchivableDictionary are the only supported types."); } } } DA.SetData(0, props); }
protected override void SolveInstance(IGH_DataAccess DA) { GsaMember3d gsaMember3d = new GsaMember3d(); if (DA.GetData(0, ref gsaMember3d)) { if (gsaMember3d == null) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Member3D input is null"); } GsaMember3d mem = gsaMember3d.Duplicate(); // #### inputs #### // 1 ID GH_Integer ghID = new GH_Integer(); if (DA.GetData(1, ref ghID)) { if (GH_Convert.ToInt32(ghID, out int id, GH_Conversion.Both)) { mem.ID = id; } } // 2 geometry GH_ObjectWrapper gh_typ = new GH_ObjectWrapper(); if (DA.GetData(2, ref gh_typ)) { GsaMember3d tempMem = new GsaMember3d(); Brep brep = new Brep(); Mesh mesh = new Mesh(); if (GH_Convert.ToBrep(gh_typ.Value, ref brep, GH_Conversion.Both)) { tempMem = new GsaMember3d(brep); } else if (GH_Convert.ToMesh(gh_typ.Value, ref mesh, GH_Conversion.Both)) { tempMem = new GsaMember3d(mesh); } else { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Unable to convert Geometry input to a 3D Member"); return; } mem.SolidMesh = tempMem.SolidMesh; } // 3 prop3d -- to be implemented GsaAPI gh_typ = new GH_ObjectWrapper(); if (DA.GetData(3, ref gh_typ)) { if (GH_Convert.ToInt32(gh_typ.Value, out int idd, GH_Conversion.Both)) { mem.Member.Property = idd; } //GsaProp3d prop3d = new GsaProp3d(); //if (gh_typ.Value is GsaProp3dGoo) // gh_typ.CastTo(ref prop3d); //else //{ // if (GH_Convert.ToInt32(gh_typ.Value, out int idd, GH_Conversion.Both)) // prop3d.ID = idd; // else // { // AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Unable to convert PA input to a 3D Property of reference integer"); // return; // } //} //mem.Property = prop3d; } // 4 mesh size GH_Number ghmsz = new GH_Number(); if (DA.GetData(4, ref ghmsz)) { if (GH_Convert.ToDouble(ghmsz, out double msz, GH_Conversion.Both)) { mem.Member.MeshSize = msz; } } // 5 mesh with others GH_Boolean ghbool = new GH_Boolean(); if (DA.GetData(5, ref ghbool)) { if (GH_Convert.ToBoolean(ghbool, out bool mbool, GH_Conversion.Both)) { //mem.member.MeshWithOthers } } // 6 name GH_String ghnm = new GH_String(); if (DA.GetData(6, ref ghnm)) { if (GH_Convert.ToString(ghnm, out string name, GH_Conversion.Both)) { mem.Member.Name = name; } } // 7 Group GH_Integer ghgrp = new GH_Integer(); if (DA.GetData(7, ref ghgrp)) { if (GH_Convert.ToInt32(ghgrp, out int grp, GH_Conversion.Both)) { mem.Member.Group = grp; } } // 8 Colour GH_Colour ghcol = new GH_Colour(); if (DA.GetData(8, ref ghcol)) { if (GH_Convert.ToColor(ghcol, out System.Drawing.Color col, GH_Conversion.Both)) { mem.Member.Colour = col; } } // 9 Dummy GH_Boolean ghdum = new GH_Boolean(); if (DA.GetData(9, ref ghdum)) { if (GH_Convert.ToBoolean(ghdum, out bool dum, GH_Conversion.Both)) { mem.Member.IsDummy = dum; } } // #### outputs #### DA.SetData(0, new GsaMember3dGoo(mem)); DA.SetData(1, mem.ID); DA.SetData(2, mem.SolidMesh); //DA.SetData(3, mem.Property); DA.SetData(4, mem.Member.MeshSize); //DA.SetData(5, mem.Member.MeshWithOthers); DA.SetData(6, mem.Member.Name); DA.SetData(7, mem.Member.Group); DA.SetData(8, mem.Member.Colour); DA.SetData(9, mem.Member.IsDummy); } }
/// <summary> /// Determines object type and calls the appropriate conversion call. /// </summary> /// <param name="o">Object to convert.</param> /// <param name="getEncoded">If set to true, will return a base64 encoded value of more complex objects (ie, breps).</param> /// <returns></returns> private static SpeckleObject fromGhRhObject(object o, bool getEncoded = false, bool getAbstract = true) { GH_Interval int1d = o as GH_Interval; if (int1d != null) { return(GhRhConveter.fromInterval(int1d.Value)); } if (o is Interval) { return(GhRhConveter.fromInterval((Interval)o)); } GH_Interval2D int2d = o as GH_Interval2D; if (int2d != null) { return(GhRhConveter.fromInterval2d(int2d.Value)); } if (o is UVInterval) { return(GhRhConveter.fromInterval2d((UVInterval)o)); } // basic stuff GH_Number num = o as GH_Number; if (num != null) { return(SpeckleConverter.fromNumber(num.Value)); } if (o is double || o is int) { return(SpeckleConverter.fromNumber((double)o)); } GH_Boolean bul = o as GH_Boolean; if (bul != null) { return(SpeckleConverter.fromBoolean(bul.Value)); } if (o is Boolean) { return(GhRhConveter.fromBoolean((bool)o)); } GH_String str = o as GH_String; if (str != null) { return(SpeckleConverter.fromString(str.Value)); } if (o is string) { return(SpeckleConverter.fromString((string)o)); } // simple geometry GH_Point point = o as GH_Point; if (point != null) { return(GhRhConveter.fromPoint(point.Value)); } if (o is Point3d) { return(GhRhConveter.fromPoint((Point3d)o)); } // added because when we assign user data to points they get converted to points. // the above comment does makes sense. check the sdk. if (o is Rhino.Geometry.Point) { return(GhRhConveter.fromPoint(((Rhino.Geometry.Point)o).Location)); } GH_Vector vector = o as GH_Vector; if (vector != null) { return(GhRhConveter.fromVector(vector.Value)); } if (o is Vector3d) { return(GhRhConveter.fromVector((Vector3d)o)); } GH_Plane plane = o as GH_Plane; if (plane != null) { return(GhRhConveter.fromPlane(plane.Value)); } if (o is Plane) { return(GhRhConveter.fromPlane((Plane)o)); } GH_Line line = o as GH_Line; if (line != null) { return(GhRhConveter.fromLine(line.Value)); } if (o is Line) { return(GhRhConveter.fromLine((Line)o)); } GH_Arc arc = o as GH_Arc; if (arc != null) { return(GhRhConveter.fromArc(arc.Value)); } if (o is Arc) { return(GhRhConveter.fromArc((Arc)o)); } GH_Circle circle = o as GH_Circle; if (circle != null) { return(GhRhConveter.fromCircle(circle.Value)); } if (o is Circle) { return(GhRhConveter.fromCircle((Circle)o)); } GH_Rectangle rectangle = o as GH_Rectangle; if (rectangle != null) { return(GhRhConveter.fromRectangle(rectangle.Value)); } if (o is Rectangle3d) { return(GhRhConveter.fromRectangle((Rectangle3d)o)); } GH_Box box = o as GH_Box; if (box != null) { return(GhRhConveter.fromBox(box.Value)); } if (o is Box) { return(GhRhConveter.fromBox((Box)o)); } // getting complex GH_Curve curve = o as GH_Curve; if (curve != null) { Polyline poly; if (curve.Value.TryGetPolyline(out poly)) { return(GhRhConveter.fromPolyline(poly)); } return(GhRhConveter.fromCurve(curve.Value, getEncoded, getAbstract)); } if (o is Polyline) { return(GhRhConveter.fromPolyline((Polyline)o)); } if (o is Curve) { return(GhRhConveter.fromCurve((Curve)o, getEncoded, getAbstract)); } GH_Surface surface = o as GH_Surface; if (surface != null) { return(GhRhConveter.fromBrep(surface.Value, getEncoded, getAbstract)); } GH_Brep brep = o as GH_Brep; if (brep != null) { return(GhRhConveter.fromBrep(brep.Value, getEncoded, getAbstract)); } if (o is Brep) { return(GhRhConveter.fromBrep((Brep)o, getEncoded, getAbstract)); } GH_Mesh mesh = o as GH_Mesh; if (mesh != null) { return(GhRhConveter.fromMesh(mesh.Value)); } if (o is Mesh) { return(GhRhConveter.fromMesh((Mesh)o)); } return(new SpeckleObject() { hash = "404", value = "Type not supported", type = "404" }); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { // Declare variables List <string> keys = new List <string>(); List <object> values = new List <object>(); // Reference the inputs if (!DA.GetDataList(0, keys)) { return; } if (!DA.GetDataList(1, values)) { return; } // Make sure same number of keys and values if (keys.Count != values.Count) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "There must must be the same number of keys and values per object."); } // Create a dictionary IDictionary <string, object> properties = new ExpandoObject(); for (int i = 0; i < keys.Count; i++) { if (values[i] is GH_Boolean) { GH_Boolean n = (GH_Boolean)values[i]; bool value = n.Value; properties[keys[i]] = value; } else if (values[i] is GH_Number) { GH_Number n = (GH_Number)values[i]; double value = n.Value; properties[keys[i]] = value; } else if (values[i] is GH_Integer) { GH_Integer n = (GH_Integer)values[i]; int value = n.Value; properties[keys[i]] = value; } else if (values[i] is GH_String) { GH_String n = (GH_String)values[i]; string value = n.Value; properties[keys[i]] = value; } else { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, $"Item of type [{values[i].GetType()}] is not supported. Only support GH_Bool, GH_Number, GH_Integer, and GH_String."); } } // Wrap in a custom class UserData userData = new UserData(properties); // Set output references DA.SetData(0, userData); }
public void SetInputs(List <DataTree <ResthopperObject> > values) { foreach (var tree in values) { if (!_input.TryGetValue(tree.ParamName, out var inputGroup)) { continue; } if (inputGroup.AlreadySet(tree)) { LogDebug("Skipping input tree... same input"); continue; } inputGroup.CacheTree(tree); IGH_ContextualParameter contextualParameter = inputGroup.Param as IGH_ContextualParameter; if (contextualParameter != null) { switch (ParamTypeName(inputGroup.Param)) { case "Number": { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { double[] doubles = new double[entree.Value.Count]; for (int i = 0; i < doubles.Length; i++) { ResthopperObject restobj = entree.Value[i]; doubles[i] = JsonConvert.DeserializeObject <double>(restobj.Data); } contextualParameter.AssignContextualData(doubles); break; } } break; case "Integer": { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { int[] integers = new int[entree.Value.Count]; for (int i = 0; i < integers.Length; i++) { ResthopperObject restobj = entree.Value[i]; integers[i] = JsonConvert.DeserializeObject <int>(restobj.Data); } contextualParameter.AssignContextualData(integers); break; } } break; case "Point": { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { Point3d[] points = new Point3d[entree.Value.Count]; for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; points[i] = JsonConvert.DeserializeObject <Rhino.Geometry.Point3d>(restobj.Data); } contextualParameter.AssignContextualData(points); break; } } break; case "Line": { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { Line[] lines = new Line[entree.Value.Count]; for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; lines[i] = JsonConvert.DeserializeObject <Rhino.Geometry.Line>(restobj.Data); } contextualParameter.AssignContextualData(lines); break; } } break; case "Text": { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { string[] strings = new string[entree.Value.Count]; for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; strings[i] = restobj.Data.Trim(new char[] { '"' }); } contextualParameter.AssignContextualData(strings); break; } } break; case "Geometry": { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GeometryBase[] geometries = new GeometryBase[entree.Value.Count]; for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; var dict = JsonConvert.DeserializeObject <Dictionary <string, string> >(restobj.Data); geometries[i] = Rhino.Runtime.CommonObject.FromJSON(dict) as GeometryBase; } contextualParameter.AssignContextualData(geometries); break; } } break; } continue; } inputGroup.Param.VolatileData.Clear(); inputGroup.Param.ExpireSolution(false); // mark param as expired but don't recompute just yet! if (inputGroup.Param is Param_Point) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Point3d rPt = JsonConvert.DeserializeObject <Rhino.Geometry.Point3d>(restobj.Data); GH_Point data = new GH_Point(rPt); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Vector) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Vector3d rhVector = JsonConvert.DeserializeObject <Rhino.Geometry.Vector3d>(restobj.Data); GH_Vector data = new GH_Vector(rhVector); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Integer) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; int rhinoInt = JsonConvert.DeserializeObject <int>(restobj.Data); GH_Integer data = new GH_Integer(rhinoInt); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Number) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; double rhNumber = JsonConvert.DeserializeObject <double>(restobj.Data); GH_Number data = new GH_Number(rhNumber); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_String) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; string rhString = restobj.Data; GH_String data = new GH_String(rhString); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Line) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Line rhLine = JsonConvert.DeserializeObject <Rhino.Geometry.Line>(restobj.Data); GH_Line data = new GH_Line(rhLine); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Curve) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; GH_Curve ghCurve; try { Rhino.Geometry.Polyline data = JsonConvert.DeserializeObject <Rhino.Geometry.Polyline>(restobj.Data); Rhino.Geometry.Curve c = new Rhino.Geometry.PolylineCurve(data); ghCurve = new GH_Curve(c); } catch { var dict = JsonConvert.DeserializeObject <Dictionary <string, string> >(restobj.Data); var c = (Rhino.Geometry.Curve)Rhino.Runtime.CommonObject.FromJSON(dict); ghCurve = new GH_Curve(c); } inputGroup.Param.AddVolatileData(path, i, ghCurve); } } continue; } if (inputGroup.Param is Param_Circle) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Circle rhCircle = JsonConvert.DeserializeObject <Rhino.Geometry.Circle>(restobj.Data); GH_Circle data = new GH_Circle(rhCircle); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Plane) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Plane rhPlane = JsonConvert.DeserializeObject <Rhino.Geometry.Plane>(restobj.Data); GH_Plane data = new GH_Plane(rhPlane); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Rectangle) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Rectangle3d rhRectangle = JsonConvert.DeserializeObject <Rhino.Geometry.Rectangle3d>(restobj.Data); GH_Rectangle data = new GH_Rectangle(rhRectangle); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Box) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Box rhBox = JsonConvert.DeserializeObject <Rhino.Geometry.Box>(restobj.Data); GH_Box data = new GH_Box(rhBox); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Surface) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Surface rhSurface = JsonConvert.DeserializeObject <Rhino.Geometry.Surface>(restobj.Data); GH_Surface data = new GH_Surface(rhSurface); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Brep) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Brep rhBrep = JsonConvert.DeserializeObject <Rhino.Geometry.Brep>(restobj.Data); GH_Brep data = new GH_Brep(rhBrep); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Mesh) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Mesh rhMesh = JsonConvert.DeserializeObject <Rhino.Geometry.Mesh>(restobj.Data); GH_Mesh data = new GH_Mesh(rhMesh); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is GH_NumberSlider) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; double rhNumber = JsonConvert.DeserializeObject <double>(restobj.Data); GH_Number data = new GH_Number(rhNumber); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Boolean || inputGroup.Param is GH_BooleanToggle) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; bool boolean = JsonConvert.DeserializeObject <bool>(restobj.Data); GH_Boolean data = new GH_Boolean(boolean); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is GH_Panel) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; string rhString = JsonConvert.DeserializeObject <string>(restobj.Data); GH_String data = new GH_String(rhString); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } } }
protected override void SolveInstance(IGH_DataAccess DA) { // inputs var points = new List <GH_Point>(); var vectors = new List <GH_Vector>(); var startPoints = new List <GH_Point>(); var lifeTime = new GH_Integer(); var settings = new GH_ObjectWrapper(); var reset = new GH_Boolean(); var dynamicsWrapped = new List <GH_ObjectWrapper>(); var dynamics = new List <IDynamic>(); if (DA.GetDataList(0, points) && points == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid points list. Operation canceled."); return; } if (DA.GetDataList(1, vectors) && vectors == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid vector list. Operation canceled."); return; } if (vectors.Count != points.Count && vectors.Count != 0) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Vector list size mismatch with points list, they must be equal in length (or empty). Operation canceled."); return; } if (DA.GetDataList(2, startPoints) && startPoints == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid travelling points. Operation canceled."); return; } if (DA.GetData(3, ref lifeTime) && lifeTime == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid lifetime input. Operation canceled."); return; } if (DA.GetDataList(4, dynamicsWrapped) && dynamicsWrapped == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid dynamics list. Operation canceled."); return; } dynamics = (from d in dynamicsWrapped select d.Value as IDynamic).ToList(); Algos.SortDynamicsByPriority(dynamics); // if vectors list is empty we'll populate it with empty vectors to match each point if (vectors.Count == 0) { for (int i = 0; i < points.Count; i++) { vectors.Add(new GH_Vector()); } } // spm parameters component is optional, we use its defaults if it is not available var spm_settings = new DynamicSettings(); if (DA.GetData(5, ref settings)) { // if getdata succeeded but the settings var is null we had bad input if (settings == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid settings input. Operation canceled."); return; } // otherwise cast from gh_objectwrapper and continue spm_settings = (DynamicSettings)settings.Value; } if (DA.GetData(6, ref reset) && reset == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid reset input. Operation canceled."); return; } if (emitter == null || reset.Value) { emitter = new Emitter(startPoints, lifeTime.Value, spm_settings); DA.SetDataList(0, startPoints); var zv = new List <GH_Vector>(startPoints.Count); for (int i = 0; i < startPoints.Count; i++) { zv.Add(new GH_Vector()); } Algos.ClearDynamics(dynamics); DA.SetDataList(1, zv); return; } // emitter updates dynamics emitter.Update(dynamics, points, vectors, spm_settings); DA.SetDataList(0, emitter.Points); DA.SetDataList(1, emitter.Vectors); }
/// <summary> /// Attempt a cast from generic object. /// </summary> /// <param name="source"> Reference to source of cast. </param> /// <returns> True on success, false on failure. </returns> public override bool CastFrom(object source) { if (source == null) { return(false); } //Cast from Auto Axis Config if (typeof(AutoAxisConfig).IsAssignableFrom(source.GetType())) { Value = source as AutoAxisConfig; return(true); } //Cast from Boolean if (typeof(GH_Boolean).IsAssignableFrom(source.GetType())) { GH_Boolean ghBoolean = source as GH_Boolean; Value = new AutoAxisConfig(ghBoolean.Value); return(true); } //Cast from Action if (typeof(RobotComponents.Actions.Action).IsAssignableFrom(source.GetType())) { if (source is AutoAxisConfig action) { Value = action; return(true); } } //Cast from Action Goo if (typeof(GH_Action).IsAssignableFrom(source.GetType())) { GH_Action actionGoo = source as GH_Action; if (actionGoo.Value is AutoAxisConfig action) { Value = action; return(true); } } //Cast from Instruction if (typeof(IInstruction).IsAssignableFrom(source.GetType())) { if (source is AutoAxisConfig instruction) { Value = instruction; return(true); } } //Cast from Instruction Goo if (typeof(GH_Instruction).IsAssignableFrom(source.GetType())) { GH_Instruction instructionGoo = source as GH_Instruction; if (instructionGoo.Value is AutoAxisConfig instruction) { Value = instruction; return(true); } } return(false); }
protected override void SolveInstance(IGH_DataAccess DA) { GH_Surface surface = new GH_Surface(); GH_String level = new GH_String(); GH_String family = new GH_String(""); GH_String type = new GH_String(""); GH_Boolean structural = new GH_Boolean(false); GH_Number slope = new GH_Number(0.0); List<Parameter> parameters = new List<Parameter>(); if (!DA.GetDataList<Parameter>("Parameters", parameters)) parameters = new List<Parameter>(); DA.GetData<GH_Surface>("Surface", ref surface); GH_Point slopeTopPoint = new GH_Point(surface.Value.Edges[0].PointAtStart); GH_Point slopeBottomPoint = new GH_Point(surface.Value.Edges[0].PointAtEnd); //DA.GetData<GH_String>("Family", ref family); //DA.GetData<GH_String>("Type", ref type); DA.GetData<GH_String>("Levelbottom", ref level); DA.GetData<GH_Boolean>("Structural", ref structural); DA.GetData<GH_Point>("SlopeTopPoint", ref slopeTopPoint); DA.GetData<GH_Point>("SlopeBottomPoint", ref slopeBottomPoint); DA.GetData<GH_Number>("Slope", ref slope); Slab slab = new Slab(); slab.FamilyOrStyle = family.Value; slab.TypeOrLayer = type.Value; slab.levelbottom = level.Value; slab.structural = structural.Value; slab.surface = new Profile(); slab.surface.profile = new List<Loop>(); Loop loop = new Loop(); loop.outline = new List<Component>(); foreach (Rhino.Geometry.BrepEdge be in surface.Value.Edges) { loop.outline.Add(be.ToNurbsCurve().ToGrevitCurve()); } slab.surface.profile.Add(loop); slab.parameters = parameters; slab.top = slopeTopPoint.ToGrevitPoint(); slab.bottom = slopeBottomPoint.ToGrevitPoint(); slab.slope = slope.Value; slab.GID = this.InstanceGuid.ToString(); DA.SetData("GrevitComponent", slab); }
////////////////////////////// CastTo //////////////////////////////////// public override bool CastTo <Q>(ref Q target) { if (typeof(Q).IsAssignableFrom(typeof(string))) { object s = Value.ToString(); target = (Q)s; return(true); } if (Value.IntegerQ()) { if (typeof(Q).IsAssignableFrom(typeof(Int32))) { object i = (int)Value; target = (Q)i; return(true); } else if (typeof(Q).IsAssignableFrom(typeof(Int64))) { object i = Value.AsInt64(); target = (Q)i; return(true); } else if (typeof(Q).IsAssignableFrom(typeof(GH_Integer))) { object ptr = new GH_Integer((int)Value.AsInt64()); target = (Q)ptr; return(true); } else if (typeof(Q).IsAssignableFrom(typeof(Double))) { object d = Value.AsDouble(); target = (Q)d; return(true); } else if (typeof(Q).IsAssignableFrom(typeof(GH_Number))) { object d = new GH_Number(Value.AsDouble()); target = (Q)d; return(true); } } if (Value.NumberQ()) { if (typeof(Q).IsAssignableFrom(typeof(Double))) { object d = Value.AsDouble(); target = (Q)d; return(true); } else if (typeof(Q).IsAssignableFrom(typeof(GH_Number))) { object d = new GH_Number(Value.AsDouble()); target = (Q)d; return(true); } } if (Value.StringQ() || Value.SymbolQ()) { if (typeof(Q).IsAssignableFrom(typeof(string))) { object s = Value.ToString(); target = (Q)s; return(true); } else if (typeof(Q).IsAssignableFrom(typeof(GH_String))) { object s = new GH_String(Value.ToString()); target = (Q)s; return(true); } } if (Value.TrueQ() || Value.SymbolQ() && Value.ToString() == "False") { if (typeof(Q).IsAssignableFrom(typeof(bool))) { object s = Value.TrueQ() ? true : false; target = (Q)s; return(true); } else if (typeof(Q).IsAssignableFrom(typeof(GH_Boolean))) { object s = new GH_Boolean(Value.TrueQ() ? true : false); target = (Q)s; return(true); } } // Try to convert to an array. // TODO. This is not yet implemented. Any why am Idoing Array? Shouldn't this be List or GH_Structure? object dataArray = null; try { if (Value.Head.Equals(SYM_LIST)) { int[] dims = Value.Dimensions; if (dims.Length == 1) { try { dataArray = Value.AsArray(ExpressionType.Integer, 1); } catch (Exception) { dataArray = Value.AsArray(ExpressionType.Real, 1); } if (dataArray != null) { target = (Q)dataArray; return(true); } } else if (dims.Length == 2) { // TODO } } } catch (Exception) { } // TODO: More types, like ComplexNumber. return(false); }
protected override void SolveInstance(IGH_DataAccess DA) { // inputs var points = new List <GH_Point>(); var vectors = new List <GH_Vector>(); var startPoints = new List <GH_Point>(); var reset = new GH_Boolean(); var settings = new GH_ObjectWrapper(); if (DA.GetDataList(0, points) && points == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid points list. Operation canceled."); return; } if (DA.GetDataList(1, vectors) && vectors == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid vector list. Operation canceled."); return; } if (vectors.Count != points.Count) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Vector list size mismatch with points list, they must be equal in length. Operation canceled."); return; } if (DA.GetDataList(2, startPoints) && startPoints == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid travelling points. Operation canceled."); return; } // spm parameters component is optional, we use its defaults if it is not available SPM_Parameters spm_settings = new SPM_Parameters(); if (DA.GetData(3, ref settings)) { // if getdata succeeded but the settings var is null we had bad input if (settings == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid settings input. Operation canceled."); return; } // otherwise cast from gh_objectwrapper and continue spm_settings = (SPM_Parameters)settings.Value; } if (DA.GetData(4, ref reset) && reset == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid reset input. Operation canceled."); return; } if (startBasis == null || reset.Value) { var count = startPoints.Count; startBasis = new Basis[count]; lastVecs = new GH_Vector[count]; xy = new double[count]; yz = new double[count]; xz = new double[count]; for (int i = 0; i < count; i++) { startBasis[i] = new Basis(startPoints[i]); lastVecs[i] = new GH_Vector(); xy[i] = 0; yz[i] = 0; xz[i] = 0; } } if (moving == null || reset.Value) { moving = startPoints; return; } int steps = spm_settings.steps; if (steps == 0) { steps = 1; } var bases = new List <Basis>(); for (int i = 0; i < points.Count; i++) { bases.Add(new Basis(points[i], vectors[i])); } // find each next point based on an averaging formula and iterate for (int i = 0; i < startPoints.Count; i++) { for (int j = 0; j < steps; j++) { bool add = false; var outBasis = new Basis(); bool working = Algos.SampleForNextPoint(bases, moving[i].Value, startBasis[i], lastVecs[i], spm_settings, out outBasis, out add); if (spm_settings.stop && spm_settings.windAngle != 0.0d) { if (!lastVecs[i].Value.IsZero) { double cxy = xy[i]; double cyz = yz[i]; double cxz = xz[i]; if (Algos.IsWoundPast(outBasis.Vector.Value, lastVecs[i].Value, spm_settings.windAngle, ref cxy, ref cyz, ref cxz)) { break; } xy[i] = cxy; yz[i] = cyz; xz[i] = cxz; } } lastVecs[i] = outBasis.Vector; if (working && startBasis[i].Vector.Value.IsZero) { startBasis[i].Vector.Value = moving[i].Value - startBasis[i].Point.Value; } if (add) { moving[i] = outBasis.Point; } if (!working) { moving[i] = startPoints[i]; } } } DA.SetDataList(0, moving); }
public void SetInputs(List <DataTree <ResthopperObject> > values) { foreach (var tree in values) { if (!_input.TryGetValue(tree.ParamName, out var inputGroup)) { continue; } if (inputGroup.AlreadySet(tree)) { Console.WriteLine("Skipping input tree... same input"); continue; } inputGroup.CacheTree(tree); inputGroup.Param.VolatileData.Clear(); inputGroup.Param.ExpireSolution(true); if (inputGroup.Param is Param_Point) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Point3d rPt = JsonConvert.DeserializeObject <Rhino.Geometry.Point3d>(restobj.Data); GH_Point data = new GH_Point(rPt); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Vector) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Vector3d rhVector = JsonConvert.DeserializeObject <Rhino.Geometry.Vector3d>(restobj.Data); GH_Vector data = new GH_Vector(rhVector); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Integer) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; int rhinoInt = JsonConvert.DeserializeObject <int>(restobj.Data); GH_Integer data = new GH_Integer(rhinoInt); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Number) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; double rhNumber = JsonConvert.DeserializeObject <double>(restobj.Data); GH_Number data = new GH_Number(rhNumber); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_String) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; string rhString = restobj.Data; GH_String data = new GH_String(rhString); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Line) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Line rhLine = JsonConvert.DeserializeObject <Rhino.Geometry.Line>(restobj.Data); GH_Line data = new GH_Line(rhLine); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Curve) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; GH_Curve ghCurve; try { Rhino.Geometry.Polyline data = JsonConvert.DeserializeObject <Rhino.Geometry.Polyline>(restobj.Data); Rhino.Geometry.Curve c = new Rhino.Geometry.PolylineCurve(data); ghCurve = new GH_Curve(c); } catch { var dict = JsonConvert.DeserializeObject <Dictionary <string, string> >(restobj.Data); var c = (Rhino.Geometry.Curve)Rhino.Runtime.CommonObject.FromJSON(dict); ghCurve = new GH_Curve(c); } inputGroup.Param.AddVolatileData(path, i, ghCurve); } } continue; } if (inputGroup.Param is Param_Circle) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Circle rhCircle = JsonConvert.DeserializeObject <Rhino.Geometry.Circle>(restobj.Data); GH_Circle data = new GH_Circle(rhCircle); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Plane) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Plane rhPlane = JsonConvert.DeserializeObject <Rhino.Geometry.Plane>(restobj.Data); GH_Plane data = new GH_Plane(rhPlane); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Rectangle) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Rectangle3d rhRectangle = JsonConvert.DeserializeObject <Rhino.Geometry.Rectangle3d>(restobj.Data); GH_Rectangle data = new GH_Rectangle(rhRectangle); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Box) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Box rhBox = JsonConvert.DeserializeObject <Rhino.Geometry.Box>(restobj.Data); GH_Box data = new GH_Box(rhBox); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Surface) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Surface rhSurface = JsonConvert.DeserializeObject <Rhino.Geometry.Surface>(restobj.Data); GH_Surface data = new GH_Surface(rhSurface); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Brep) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Brep rhBrep = JsonConvert.DeserializeObject <Rhino.Geometry.Brep>(restobj.Data); GH_Brep data = new GH_Brep(rhBrep); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Mesh) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; Rhino.Geometry.Mesh rhMesh = JsonConvert.DeserializeObject <Rhino.Geometry.Mesh>(restobj.Data); GH_Mesh data = new GH_Mesh(rhMesh); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is GH_NumberSlider) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; double rhNumber = JsonConvert.DeserializeObject <double>(restobj.Data); GH_Number data = new GH_Number(rhNumber); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is Param_Boolean || inputGroup.Param is GH_BooleanToggle) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; bool boolean = JsonConvert.DeserializeObject <bool>(restobj.Data); GH_Boolean data = new GH_Boolean(boolean); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } if (inputGroup.Param is GH_Panel) { foreach (KeyValuePair <string, List <ResthopperObject> > entree in tree) { GH_Path path = new GH_Path(GhPath.FromString(entree.Key)); for (int i = 0; i < entree.Value.Count; i++) { ResthopperObject restobj = entree.Value[i]; string rhString = JsonConvert.DeserializeObject <string>(restobj.Data); GH_String data = new GH_String(rhString); inputGroup.Param.AddVolatileData(path, i, data); } } continue; } } }
protected override void SolveInstance(IGH_DataAccess DA) { GH_Boolean assoc = new GH_Boolean(false); GH_String name = new GH_String(); GH_String layer = new GH_String(""); GH_String style = new GH_String(""); GH_String number = new GH_String(); List<Parameter> param = new List<Parameter>(); List<GH_Point> points = new List<GH_Point>(); if (!DA.GetDataList<Parameter>("Parameters", param)) param = new List<Parameter>(); if (!DA.GetDataList<GH_Point>("Points", points)) points = new List<GH_Point>(); DA.GetData<GH_String>("Name", ref name); DA.GetData<GH_Boolean>("Assoc", ref assoc); DA.GetData<GH_String>("Number", ref number); DA.GetData<GH_String>("Style", ref style); DA.GetData<GH_String>("Layer", ref layer); Room ac = new Room(name.Value,number.Value,"",param); IEnumerable<GH_Point> nodups = points.Distinct(new GH_PointComparer()); ac.points = new List<Grevit.Types.Point>(); foreach (var p in nodups) { ac.points.Add(p.ToGrevitPoint()); } ac.associative = assoc.Value; ac.FamilyOrStyle = style.Value; ac.TypeOrLayer = layer.Value; ac.GID = this.InstanceGuid.ToString(); DA.SetData("GrevitComponent", ac); }
protected override void SolveInstance(IGH_DataAccess DA) { GH_Surface surface = new GH_Surface(); GH_String lvlbtm = new GH_String(""); GH_String style = new GH_String(""); GH_String layer = new GH_String(""); GH_Number taperAng = new GH_Number(0); GH_Number height = new GH_Number(); GH_Point stop = new GH_Point(); GH_Point sbtm = new GH_Point(); GH_Boolean structural = new GH_Boolean(true); List<Parameter> param = new List<Parameter>(); if (!DA.GetDataList<Parameter>("Parameters", param)) param = new List<Parameter>(); DA.GetData<GH_Surface>("Surface", ref surface); DA.GetData<GH_String>("Layer", ref layer); //DA.GetData<GH_String>("Style", ref style); DA.GetData<GH_Number>("taperAngle", ref taperAng); DA.GetData<GH_Number>("height", ref height); Slab s = new Slab(); s.FamilyOrStyle = style.Value; s.TypeOrLayer = layer.Value; s.levelbottom = lvlbtm.Value; s.structural = structural.Value; s.surface = new Surface(); s.surface.outline = new List<Component>(); foreach (Rhino.Geometry.BrepEdge be in surface.Value.Edges) { s.surface.outline.Add(be.ToNurbsCurve().ToGrevitCurve()); } s.height = height.Value; s.parameters = param; //s.top = ComponentUtilities.GHPoint2Point(stop); //s.bottom = ComponentUtilities.GHPoint2Point(sbtm); s.slope = taperAng.Value; s.GID = this.InstanceGuid.ToString(); //SetPreview(s.GID, surface.Value); DA.SetData("GrevitComponent", s); }
protected override void SolveInstance(IGH_DataAccess DA) { GsaGridLineLoad gridlineload = new GsaGridLineLoad(); // 0 Load case int lc = 1; GH_Integer gh_lc = new GH_Integer(); if (DA.GetData(0, ref gh_lc)) { GH_Convert.ToInt32(gh_lc, out lc, GH_Conversion.Both); } gridlineload.GridLineLoad.Case = lc; // Do plane input first as to see if we need to project polyline onto grid plane // 2 Plane Plane pln = Plane.WorldXY; bool planeSet = false; GsaGridPlaneSurface grdplnsrf = new GsaGridPlaneSurface(); GH_ObjectWrapper gh_typ = new GH_ObjectWrapper(); if (DA.GetData(2, ref gh_typ)) { if (gh_typ.Value is GsaGridPlaneSurfaceGoo) { GsaGridPlaneSurface temppln = new GsaGridPlaneSurface(); gh_typ.CastTo(ref temppln); grdplnsrf = temppln.Duplicate(); pln = grdplnsrf.Plane; planeSet = true; } else if (gh_typ.Value is Plane) { gh_typ.CastTo(ref pln); grdplnsrf = new GsaGridPlaneSurface(pln); planeSet = true; } else { int id = 0; if (GH_Convert.ToInt32(gh_typ.Value, out id, GH_Conversion.Both)) { gridlineload.GridLineLoad.GridSurface = id; gridlineload.GridPlaneSurface = null; } else { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Error in GPS input. Accepted inputs are Grid Plane Surface or Plane. " + System.Environment.NewLine + "If no input here then the line's best-fit plane will be used"); return; } } } // we wait setting the gridplanesurface until we have run the polyline input // 1 Polyline Polyline ln = new Polyline(); GH_Curve gh_crv = new GH_Curve(); if (DA.GetData(1, ref gh_crv)) { Curve crv = null; GH_Convert.ToCurve(gh_crv, ref crv, GH_Conversion.Both); //convert to polyline if (crv.TryGetPolyline(out ln)) { // get control points List <Point3d> ctrl_pts = ln.ToList(); // plane if (!planeSet) { // create best-fit plane from pts pln = Util.GH.Convert.CreateBestFitUnitisedPlaneFromPts(ctrl_pts); // create grid plane surface from best fit plane grdplnsrf = new GsaGridPlaneSurface(pln, true); } else { // project original curve onto grid plane crv = Curve.ProjectToPlane(crv, pln); // convert to polyline again crv.TryGetPolyline(out ln); //get control points again ctrl_pts = ln.ToList(); } // string to write polyline description to string desc = ""; // loop through all points for (int i = 0; i < ctrl_pts.Count; i++) { if (i > 0) { desc += " "; } // get control points in local plane coordinates Point3d temppt = new Point3d(); pln.RemapToPlaneSpace(ctrl_pts[i], out temppt); // write point to string // format accepted by GSA: (0,0) (0,1) (1,2) (3,4) (4,0)(m) desc += "(" + temppt.X + "," + temppt.Y + ")"; } // add units to the end desc += "(" + Units.LengthLarge + ")"; // set polyline in grid line load gridlineload.GridLineLoad.Type = GridLineLoad.PolyLineType.EXPLICIT_POLYLINE; gridlineload.GridLineLoad.PolyLineDefinition = desc; } else { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Could not convert Curve to Polyline"); } } // now we can set the gridplanesurface: if (gridlineload.GridPlaneSurface != null) { if (gridlineload.GridPlaneSurface.GridSurfaceID == 0) { gridlineload.GridPlaneSurface = grdplnsrf; } } // 3 direction string dir = "Z"; Direction direc = Direction.Z; GH_String gh_dir = new GH_String(); if (DA.GetData(3, ref gh_dir)) { GH_Convert.ToString(gh_dir, out dir, GH_Conversion.Both); } dir = dir.ToUpper(); if (dir == "X") { direc = Direction.X; } if (dir == "Y") { direc = Direction.Y; } gridlineload.GridLineLoad.Direction = direc; // 4 Axis int axis = 0; gridlineload.GridLineLoad.AxisProperty = 0; GH_Integer gh_ax = new GH_Integer(); if (DA.GetData(4, ref gh_ax)) { GH_Convert.ToInt32(gh_ax, out axis, GH_Conversion.Both); if (axis == 0 || axis == -1) { gridlineload.GridLineLoad.AxisProperty = axis; } } // 5 Projected bool proj = false; GH_Boolean gh_proj = new GH_Boolean(); if (DA.GetData(5, ref gh_proj)) { if (GH_Convert.ToBoolean(gh_proj, out proj, GH_Conversion.Both)) { gridlineload.GridLineLoad.IsProjected = proj; } } // 6 Name string name = ""; GH_String gh_name = new GH_String(); if (DA.GetData(6, ref gh_name)) { if (GH_Convert.ToString(gh_name, out name, GH_Conversion.Both)) { gridlineload.GridLineLoad.Name = name; } } // 7 load value double load1 = 0; if (DA.GetData(7, ref load1)) { load1 *= -1000; //convert to kN } gridlineload.GridLineLoad.ValueAtStart = load1; // 8 load value double load2 = load1; if (DA.GetData(8, ref load2)) { load2 *= -1000; //convert to kN } gridlineload.GridLineLoad.ValueAtEnd = load2; // convert to goo GsaLoad gsaLoad = new GsaLoad(gridlineload); DA.SetData(0, new GsaLoadGoo(gsaLoad)); }