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;
}
