public static MenuBarManager.CallbackStatus ReadFromFile(string filePath, out GH_Document definition) { definition = null; try { var archive = new GH_Archive(); if (!archive.ReadFromFile(filePath)) { return(MenuBarManager.CallbackStatus.Error); } definition = new GH_Document(); if (archive.ExtractObject(definition, "Definition")) { return(MenuBarManager.CallbackStatus.Continue); } definition?.Dispose(); definition = null; return(MenuBarManager.CallbackStatus.Error); } catch (Exception) { return(MenuBarManager.CallbackStatus.Error); } }
public static Result ReadFromFile(string filePath, out GH_Document definition) { definition = null; var CurrentCulture = Thread.CurrentThread.CurrentCulture; try { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; var archive = new GH_Archive(); if (!archive.ReadFromFile(filePath)) { return(Result.Failed); } definition = new GH_Document(); if (archive.ExtractObject(definition, "Definition")) { return(Result.Succeeded); } definition?.Dispose(); definition = null; return(Result.Failed); } catch (Exception) { return(Result.Failed); } finally { Thread.CurrentThread.CurrentCulture = CurrentCulture; } }
public MedinaMotif(string name, string ghxText) { Name = name; GhArchive = new GH_Archive(); GhArchive.Deserialize_Xml(ghxText); GhDoc = new GH_Document(); GhArchive.ExtractObject(GhDoc, "Definition"); }
private static GrasshopperDefinition Construct(GH_Archive archive) { var definition = new GH_Document(); if (!archive.ExtractObject(definition, "Definition")) { throw new Exception("Unable to extract definition from archive"); } // raise DocumentServer.DocumentAdded event (used by some plug-ins) Grasshopper.Instances.DocumentServer.AddDocument(definition); GrasshopperDefinition rc = new GrasshopperDefinition(definition); foreach (var obj in definition.Objects) { IGH_ContextualParameter contextualParam = obj as IGH_ContextualParameter; if (contextualParam != null) { IGH_Param param = obj as IGH_Param; if (param != null) { rc._input[param.NickName] = new InputGroup(param); } continue; } var group = obj as GH_Group; if (group == null) { continue; } string nickname = group.NickName; var groupObjects = group.Objects(); if (nickname.Contains("RH_IN") && groupObjects.Count > 0) { var param = groupObjects[0] as IGH_Param; if (param != null) { rc._input[nickname] = new InputGroup(param); } } if (nickname.Contains("RH_OUT") && groupObjects.Count > 0) { var param = groupObjects[0] as IGH_Param; if (param != null) { rc._output[nickname] = param; } } } return(rc); }
private void RecallGraph(IGH_Graph g) { if (g != null && m_graph_history.ContainsKey(g.GraphTypeID)) { GH_Archive gH_Archive = new GH_Archive(); if (gH_Archive.Deserialize_Xml(m_graph_history[g.GraphTypeID])) { gH_Archive.ExtractObject((GH_ISerializable)g, "graph"); } } }
public MedinaMotifBuilder FromGhx(string path) { var ghxText = System.IO.File.ReadAllText(path); GhArchive = new GH_Archive(); GhArchive.Deserialize_Xml(ghxText); GhDoc = new GH_Document(); GhArchive.ExtractObject(GhDoc, "Definition"); return(this); }
// Currently need a separate RunHelper function so the .NET runtime won't attempt to load the // Grasshopper assembly until after RhinoCore has been created. This should be "fixable" in a // future version of the RhinoInside nuget package static void RunHelper() { // Extract definition to sample location as executable var assembly = typeof(Program).Assembly; string dir = System.IO.Path.GetDirectoryName(assembly.Location); string definitionPath = System.IO.Path.Combine(dir, "simple_def.gh"); using (var resStream = assembly.GetManifestResourceStream("RunGrasshopper.simple_def.gh")) using (var outStream = new System.IO.FileStream(definitionPath, System.IO.FileMode.Create)) { resStream.CopyTo(outStream); } // Start grasshopper in "headless" mode var pluginObject = Rhino.RhinoApp.GetPlugInObject("Grasshopper") as Grasshopper.Plugin.GH_RhinoScriptInterface; pluginObject.RunHeadless(); var archive = new GH_Archive(); archive.ReadFromFile(definitionPath); using (var definition = new Grasshopper.Kernel.GH_Document()) { archive.ExtractObject(definition, "Definition"); foreach (var obj in definition.Objects) { if (obj is Grasshopper.Kernel.IGH_Param param) { if (obj.NickName == "CollectMe") { param.CollectData(); param.ComputeData(); foreach (var item in param.VolatileData.AllData(true)) { Line computedLine = Line.Unset; if (item.CastTo(out computedLine)) { Console.WriteLine($"Got a line ... {computedLine}"); } } } } } } Console.WriteLine("Done... press and key to exit"); Console.ReadKey(); }
private static GrasshopperDefinition Construct(GH_Archive archive) { var definition = new GH_Document(); if (!archive.ExtractObject(definition, "Definition")) { throw new Exception("Unable to extract definition from archive"); } GrasshopperDefinition rc = new GrasshopperDefinition(definition); foreach (var obj in definition.Objects) { var group = obj as GH_Group; if (group == null) { continue; } string nickname = group.NickName; var groupObjects = group.Objects(); if (nickname.Contains("RH_IN") && groupObjects.Count > 0) { var param = groupObjects[0] as IGH_Param; if (param != null) { rc._input[nickname] = new InputGroup(param); } } if (nickname.Contains("RH_OUT") && groupObjects.Count > 0) { var param = groupObjects[0] as IGH_Param; if (param != null) { rc._output[nickname] = param; } } } return(rc); }
public static List <MedinaMotif> LoadMotifs(string path) { var archive = new GH_Archive(); var ghxText = System.IO.File.ReadAllText(path); try { archive.Deserialize_Xml(ghxText); } catch (Exception e) { Console.WriteLine(e.ToString()); } var definition = new GH_Document(); archive.ExtractObject(definition, "Definition"); Console.WriteLine($"{definition.ObjectCount.ToString()} objects in loaded definition."); foreach (var obj in definition.Objects) { var param = obj as IGH_Param; if (param == null) { continue; } if (param.Sources.Count == 0 && param.Recipients.Count != 0 && param.NickName.Length > 1) { Console.WriteLine($"Primary input named {param.NickName} discovered!"); } else if (param.NickName != null || param.NickName.Length > 1) { //Console.WriteLine($"Param {param.NickName} skipped. ({param.SourceCount.ToString()} sources / {param.Recipients.Count} recipients)"); } } return(null); }
public static Response GetIoNames(NancyContext ctx) { // load grasshopper file var archive = new GH_Archive(); // TODO: stream to string var body = ctx.Request.Body.ToString(); // //var body = input.Algo; string json = string.Empty; using (var reader = new StreamReader(ctx.Request.Body)) { json = reader.ReadToEnd(); } IoQuerySchema input = JsonConvert.DeserializeObject <IoQuerySchema>(json); string pointer = input.RequestedFile; string grasshopperXml = GetGhxFromPointer(pointer); if (!archive.Deserialize_Xml(grasshopperXml)) { throw new Exception(); } var definition = new GH_Document(); if (!archive.ExtractObject(definition, "Definition")) { throw new Exception(); } // Parse input and output names List <string> InputNames = new List <string>(); List <string> OutputNames = new List <string>(); foreach (var obj in definition.Objects) { var group = obj as GH_Group; if (group == null) { continue; } if (group.NickName.Contains("RH_IN")) { InputNames.Add(group.NickName); } else if (group.NickName.Contains("RH_OUT")) { OutputNames.Add(group.NickName); } } IoResponseSchema response = new IoResponseSchema(); response.InputNames = InputNames; response.OutputNames = OutputNames; string jsonResponse = JsonConvert.SerializeObject(response); return(jsonResponse); }
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); }
static Response GetIoNames(NancyContext ctx) { string json = ctx.Request.Body.AsString(); IoQuerySchema input = JsonConvert.DeserializeObject <IoQuerySchema>(json); string pointer = input.RequestedFile; GH_Archive archive = DataCache.GetCachedArchive(pointer); var definition = new GH_Document(); if (!archive.ExtractObject(definition, "Definition")) { throw new Exception("Unable to extract definition"); } // Parse input and output names List <string> InputNames = new List <string>(); List <string> OutputNames = new List <string>(); var Inputs = new List <IoParamSchema>(); var Outputs = new List <IoParamSchema>(); foreach (var obj in definition.Objects) { var group = obj as GH_Group; if (group == null) { continue; } if (group.NickName.Contains("RH_IN")) { InputNames.Add(group.NickName); var i = new IoParamSchema { Name = group.NickName, ParamType = (group.Objects()[0] as IGH_Param).TypeName }; Inputs.Add(i); } else if (group.NickName.Contains("RH_OUT")) { OutputNames.Add(group.NickName); var o = new IoParamSchema { Name = group.NickName, ParamType = (group.Objects()[0] as IGH_Param).TypeName }; Outputs.Add(o); } } var response = new IoResponseSchema { InputNames = InputNames, OutputNames = OutputNames, Inputs = Inputs, Outputs = Outputs }; string jsonResponse = JsonConvert.SerializeObject(response); return(jsonResponse); }
Result BakeDefinition(UIApplication application, string filePath) { if (!AddFileToMru(filePath)) { return(Result.Failed); } // Load Grasshopper PlugIn.LoadPlugIn(new Guid(0xB45A29B1, 0x4343, 0x4035, 0x98, 0x9E, 0x04, 0x4E, 0x85, 0x80, 0xD9, 0xCF)); var transactionName = string.Empty; var archive = new GH_Archive(); if (!archive.ReadFromFile(filePath)) { return(Result.Failed); } var outputs = new List <KeyValuePair <string, List <GeometryBase> > >(); using (var definition = new GH_Document()) { if (!archive.ExtractObject(definition, "Definition")) { return(Result.Failed); } // Update Most recet used item extended ToolTip information { mruPushPuttons[0].LongDescription = definition.Properties.Description; if (archive.GetRootNode.FindChunk("Thumbnail")?.GetDrawingBitmap("Thumbnail") is System.Drawing.Bitmap bitmap) { mruPushPuttons[0].ToolTipImage = bitmap.ToBitmapImage(Math.Min(bitmap.Width, 355), Math.Min(bitmap.Height, 355)); } } transactionName = Path.GetFileNameWithoutExtension(definition.Properties.ProjectFileName); var inputs = new List <IGH_Param>(); // Collect input params foreach (var obj in definition.Objects) { if (!(obj is IGH_Param param)) { continue; } if (param.Sources.Count != 0 || param.Recipients.Count == 0) { continue; } if (param.VolatileDataCount > 0) { continue; } if (param.Locked) { continue; } inputs.Add(param); } // Prompt for input values var values = new Dictionary <IGH_Param, IEnumerable <IGH_Goo> >(); foreach (var input in inputs.OrderBy((x) => x.Attributes.Pivot.Y)) { switch (input) { case Param_Box box: var boxes = PromptBox(application.ActiveUIDocument, input.NickName); if (boxes == null) { return(Result.Cancelled); } values.Add(input, boxes); break; case Param_Point point: var points = PromptPoint(application.ActiveUIDocument, input.NickName); if (points == null) { return(Result.Cancelled); } values.Add(input, points); break; case Param_Curve curve: var curves = PromptEdge(application.ActiveUIDocument, input.NickName); if (curves == null) { return(Result.Cancelled); } values.Add(input, curves); break; case Param_Surface surface: var surfaces = PromptSurface(application.ActiveUIDocument, input.NickName); if (surfaces == null) { return(Result.Cancelled); } values.Add(input, surfaces); break; case Param_Brep brep: var breps = PromptBrep(application.ActiveUIDocument, input.NickName); if (breps == null) { return(Result.Cancelled); } values.Add(input, breps); break; } } Cursor.Current = Cursors.WaitCursor; try { // Update input volatile data values foreach (var value in values) { value.Key.AddVolatileDataList(new Grasshopper.Kernel.Data.GH_Path(0), value.Value); } // Collect output values foreach (var obj in definition.Objects) { if (!(obj is IGH_Param param)) { continue; } if (param.Sources.Count == 0 || param.Recipients.Count != 0) { continue; } if (param.Locked) { continue; } try { param.CollectData(); param.ComputeData(); } catch (Exception e) { Debug.Fail(e.Source, e.Message); param.Phase = GH_SolutionPhase.Failed; } if (param.Phase == GH_SolutionPhase.Failed) { return(Result.Failed); } var output = new List <GeometryBase>(); var volatileData = param.VolatileData; if (volatileData.PathCount > 0) { foreach (var value in param.VolatileData.AllData(true).Select(x => x.ScriptVariable())) { switch (value) { case Rhino.Geometry.Point3d point: output.Add(new Rhino.Geometry.Point(point)); break; case Rhino.Geometry.GeometryBase geometry: output.Add(geometry); break; } } } if (output.Count > 0) { outputs.Add(new KeyValuePair <string, List <GeometryBase> >(param.NickName, output)); } } } catch (Exception) { return(Result.Failed); } finally { Cursor.Current = Cursors.Default; } } // Bake output geometry if (outputs.Count > 0) { var doc = application.ActiveUIDocument.Document; using (var trans = new Transaction(doc, transactionName)) { if (trans.Start(MethodBase.GetCurrentMethod().DeclaringType.Name) == TransactionStatus.Started) { if (!Enum.TryParse(categoriesComboBox.Current.Name, out BuiltInCategory builtInCategory)) { builtInCategory = BuiltInCategory.OST_GenericModel; } var categoryId = new ElementId(builtInCategory); foreach (var output in outputs) { var ds = DirectShape.CreateElement(doc, categoryId); ds.Name = output.Key; foreach (var geometries in output.Value.ToHost()) { if (geometries != null) { ds.AppendShape(geometries); } } } trans.Commit(); } } } return(Result.Succeeded); }
public Result Execute(ExternalCommandData data, ref string message, ElementSet elements) { // Load Grasshopper PlugIn.LoadPlugIn(new Guid(0xB45A29B1, 0x4343, 0x4035, 0x98, 0x9E, 0x04, 0x4E, 0x85, 0x80, 0xD9, 0xCF)); string filePath; using (var openFileDialog = new OpenFileDialog()) { openFileDialog.Filter = "Grasshopper Binary (*.gh)|*.gh|Grasshopper Xml (*.ghx)|*.ghx"; #if DEBUG openFileDialog.FilterIndex = 2; #else openFileDialog.FilterIndex = 1; #endif openFileDialog.RestoreDirectory = true; switch (openFileDialog.ShowDialog()) { case DialogResult.OK: filePath = openFileDialog.FileName; break; case DialogResult.Cancel: return(Result.Cancelled); default: return(Result.Failed); } } var transactionName = string.Empty; var archive = new GH_Archive(); if (!archive.ReadFromFile(filePath)) { return(Result.Failed); } var outputs = new List <KeyValuePair <string, List <GeometryBase> > >(); using (var definition = new GH_Document()) { if (!archive.ExtractObject(definition, "Definition")) { return(Result.Failed); } transactionName = Path.GetFileNameWithoutExtension(definition.Properties.ProjectFileName); var inputs = new List <IGH_Param>(); // Collect input params foreach (var obj in definition.Objects) { if (!(obj is IGH_Param param)) { continue; } if (param.Sources.Count != 0 || param.Recipients.Count == 0) { continue; } if (param.VolatileDataCount > 0) { continue; } if (param.Locked) { continue; } inputs.Add(param); } // Prompt for input values var values = new Dictionary <IGH_Param, IEnumerable <IGH_Goo> >(); foreach (var input in inputs.OrderBy((x) => x.Attributes.Pivot.Y)) { switch (input) { case Param_Box box: var boxes = PromptBox(data.Application.ActiveUIDocument, input.NickName); if (boxes == null) { return(Result.Cancelled); } values.Add(input, boxes); break; case Param_Point point: var points = PromptPoint(data.Application.ActiveUIDocument, input.NickName); if (points == null) { return(Result.Cancelled); } values.Add(input, points); break; case Param_Curve curve: var curves = PromptEdge(data.Application.ActiveUIDocument, input.NickName); if (curves == null) { return(Result.Cancelled); } values.Add(input, curves); break; case Param_Surface surface: var surfaces = PromptSurface(data.Application.ActiveUIDocument, input.NickName); if (surfaces == null) { return(Result.Cancelled); } values.Add(input, surfaces); break; case Param_Brep brep: var breps = PromptBrep(data.Application.ActiveUIDocument, input.NickName); if (breps == null) { return(Result.Cancelled); } values.Add(input, breps); break; } } Cursor.Current = Cursors.WaitCursor; try { // Update input volatile data values foreach (var value in values) { value.Key.AddVolatileDataList(new Grasshopper.Kernel.Data.GH_Path(0), value.Value); } // Collect output values foreach (var obj in definition.Objects) { if (!(obj is IGH_Param param)) { continue; } if (param.Sources.Count == 0 || param.Recipients.Count != 0) { continue; } if (param.Locked) { continue; } try { param.CollectData(); param.ComputeData(); } catch (Exception e) { Debug.Fail(e.Source, e.Message); param.Phase = GH_SolutionPhase.Failed; } if (param.Phase == GH_SolutionPhase.Failed) { return(Result.Failed); } var output = new List <GeometryBase>(); var volatileData = param.VolatileData; if (volatileData.PathCount > 0) { foreach (var value in param.VolatileData.AllData(true).Select(x => x.ScriptVariable())) { switch (value) { case Rhino.Geometry.Point3d point: output.Add(new Rhino.Geometry.Point(point)); break; case Rhino.Geometry.GeometryBase geometry: output.Add(geometry); break; } } } if (output.Count > 0) { outputs.Add(new KeyValuePair <string, List <GeometryBase> >(param.NickName, output)); } } } catch (Exception) { return(Result.Failed); } finally { Cursor.Current = Cursors.Default; } } // Bake output geometry if (outputs.Count > 0) { var uiApp = data.Application; var doc = uiApp.ActiveUIDocument.Document; using (var trans = new Transaction(doc, transactionName)) { if (trans.Start(MethodBase.GetCurrentMethod().DeclaringType.Name) == TransactionStatus.Started) { if (!Enum.TryParse(categoriesComboBox.Current.Name, out BuiltInCategory builtInCategory)) { builtInCategory = BuiltInCategory.OST_GenericModel; } var categoryId = new ElementId(builtInCategory); foreach (var output in outputs) { var ds = DirectShape.CreateElement(doc, categoryId); ds.Name = output.Key; foreach (var geometries in output.Value.ToHost()) { if (geometries != null) { ds.AppendShape(geometries); } } } trans.Commit(); } } } return(Result.Succeeded); }
public Result Execute(ExternalCommandData data, ref string message, ElementSet elements) { // Load Grasshopper PlugIn.LoadPlugIn(new Guid(0xB45A29B1, 0x4343, 0x4035, 0x98, 0x9E, 0x04, 0x4E, 0x85, 0x80, 0xD9, 0xCF)); string filePath; using (OpenFileDialog openFileDialog = new OpenFileDialog()) { openFileDialog.Filter = "Grasshopper Binary (*.gh)|*.gh|Grasshopper Xml (*.ghx)|*.ghx"; openFileDialog.FilterIndex = 1; openFileDialog.RestoreDirectory = true; switch (openFileDialog.ShowDialog()) { case DialogResult.OK: filePath = openFileDialog.FileName; break; case DialogResult.Cancel: return(Result.Cancelled); default: return(Result.Failed); } } var archive = new GH_Archive(); if (!archive.ReadFromFile(filePath)) { return(Result.Failed); } var outputs = new List <KeyValuePair <string, List <GeometryBase> > >(); using (var definition = new GH_Document()) { if (!archive.ExtractObject(definition, "Definition")) { return(Result.Failed); } foreach (var obj in definition.Objects) { var param = obj as IGH_Param; if (param == null) { continue; } if (param.Sources.Count == 0 || param.Recipients.Count != 0) { continue; } try { param.CollectData(); param.ComputeData(); } catch (Exception e) { Debug.Fail(e.Source, e.Message); param.Phase = GH_SolutionPhase.Failed; } if (param.Phase == GH_SolutionPhase.Failed) { return(Result.Failed); } var output = new List <GeometryBase>(); var volatileData = param.VolatileData; for (int p = 0; p < volatileData.PathCount; ++p) { foreach (var goo in volatileData.get_Branch(p)) { switch (goo) { case GH_Point point: output.Add(new Rhino.Geometry.Point(point.Value)); break; case GH_Curve curve: output.Add(curve.Value); break; case GH_Brep brep: output.Add(brep.Value); break; case GH_Mesh mesh: output.Add(mesh.Value); break; } } } if (output.Count > 0) { outputs.Add(new KeyValuePair <string, List <GeometryBase> >(param.Name, output)); } } } if (outputs.Count > 0) { var uiApp = data.Application; var doc = uiApp.ActiveUIDocument.Document; using (var trans = new Transaction(doc)) { if (trans.Start(MethodBase.GetCurrentMethod().DeclaringType.Name) == TransactionStatus.Started) { var categoryId = new ElementId(BuiltInCategory.OST_GenericModel); foreach (var output in outputs) { var ds = DirectShape.CreateElement(doc, categoryId); ds.Name = output.Key; foreach (var geometries in output.Value.ToHost()) { if (geometries != null) { ds.AppendShape(geometries); } } } trans.Commit(); } } } return(Result.Succeeded); }
void evaluateGHdef() { Debug.Log("1"); string filePath = string.Empty; using (OpenFileDialog openFileDialog = new OpenFileDialog()) { openFileDialog.Filter = "Grasshopper Binary (*.gh)|*.gh|Grasshopper Xml (*.ghx)|*.ghx"; openFileDialog.FilterIndex = 1; openFileDialog.RestoreDirectory = true; switch (openFileDialog.ShowDialog()) { case DialogResult.OK: filePath = openFileDialog.FileName; Debug.Log(filePath); break; } } var archive = new GH_Archive(); archive.ReadFromFile(filePath); var definition = new GH_Document(); archive.ExtractObject(definition, "Definition"); Debug.Log("4"); var outputs = new List <KeyValuePair <string, List <GeometryBase> > >(); foreach (var obj in definition.Objects) { var param = obj as IGH_Param; Debug.Log("5"); if (param == null) { continue; } Debug.Log("6"); if (param.Sources.Count == 0 || param.Recipients.Count != 0) { continue; } Debug.Log("7"); try { param.CollectData(); param.ComputeData(); } catch (Exception e) { //Debug.Fail(e.Source, e.Message); Debug.Log("8"); param.Phase = GH_SolutionPhase.Failed; //result = Result.Failed; } Debug.Log("9"); var volatileData = param.VolatileData; for (int p = 0; p < volatileData.PathCount; ++p) { foreach (var goo in volatileData.get_Branch(p)) { switch (goo.GetType().ToString()) { case "GH_Point": GH_Point point = (GH_Point)goo; output.Add(new Rhino.Geometry.Point(point.Value)); break; case "GH_Curve": GH_Curve curve = (GH_Curve)goo; output.Add(curve.Value); break; case "GH_Brep": GH_Brep brep = (GH_Brep)goo; output.Add(brep.Value); break; case "GH_Mesh": GH_Mesh mesh = (GH_Mesh)goo; output.Add(mesh.Value); break; } } } Debug.Log("10"); if (output.Count > 0) { outputs.Add(new KeyValuePair <string, List <GeometryBase> >(param.Name, output)); Debug.Log("11"); } } Debug.Log("There are " + output.Count() + "GH objects in your list"); //return outputs; }