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;
}
}
private static GH_Archive ReadFromFile(string filePath)
{
try
{
var archive = new GH_Archive();
archive.ReadFromFile(filePath);
return(archive);
}
catch (Exception)
{
return(null);
}
}
public static GH_Archive ArchiveFromUrl(string url)
{
if (string.IsNullOrWhiteSpace(url))
{
return(null);
}
if (File.Exists(url))
{
// local file
var archive = new GH_Archive();
if (archive.ReadFromFile(url))
{
RegisterFileWatcher(url);
return(archive);
}
return(null);
}
byte[] byteArray = null;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
request.AutomaticDecompression = DecompressionMethods.GZip;
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
using (var stream = response.GetResponseStream())
using (var memStream = new MemoryStream())
{
stream.CopyTo(memStream);
byteArray = memStream.ToArray();
}
try
{
var byteArchive = new GH_Archive();
if (byteArchive.Deserialize_Binary(byteArray))
{
return(byteArchive);
}
}
catch (Exception) { }
var grasshopperXml = StripBom(System.Text.Encoding.UTF8.GetString(byteArray));
var xmlArchive = new GH_Archive();
if (xmlArchive.Deserialize_Xml(grasshopperXml))
{
return(xmlArchive);
}
return(null);
}
// 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 GH_Archive ReadFile(string path)
{
var archive = new GH_Archive();
try
{
if (archive.ReadFromFile(path))
{
if (archive.MessageCount() > 0)
{
foreach (var msg in archive.Messages)
{
switch (msg.Type)
{
case GH_Message_Type.warning:
WriteLine(ConsoleColor.DarkYellow, " " + msg.Message);
break;
case GH_Message_Type.error:
WriteLine(ConsoleColor.Red, " " + msg.Message);
break;
}
}
}
if (archive.GetRootNode is null)
{
WriteLine(ConsoleColor.Red, "An error occured while reading that file:");
WriteLine(ConsoleColor.Red, " The archive does not contain a root node.");
Console.ReadKey(true);
return(null);
}
return(archive);
}
Console.ReadKey(true);
return(null);
}
catch (Exception ex)
{
WriteLine(ConsoleColor.Red, "An error occured while reading that file:");
WriteLine(ConsoleColor.Red, " " + ex.Message);
Console.ReadKey(true);
return(null);
}
}
//Actual constructor for use in the program
public static CommonGraph CommonGraphFromGHFile(string file)
{
CommonGraph cg = new CommonGraph();
//construct GH Archive object for XML Traversal
GH_Archive archive = new GH_Archive();
archive.ReadFromFile(file);
//traverse GH file tree
var rootNode = archive.GetRootNode;
var definition = rootNode.FindChunk("Definition");
var defObjects = definition.FindChunk("DefinitionObjects");
int objCount = defObjects.GetInt32("ObjectCount");
//for every object in the definition object list:
for (int i = 0; i < objCount; i++)
{
var singleObjectChunk = defObjects.Chunks[i] as GH_Chunk;
Guid typeGuid = singleObjectChunk.GetGuid("GUID");
var container = singleObjectChunk.FindChunk("Container");
Guid instanceGuid = container.GetGuid("InstanceGuid");
string name = singleObjectChunk.GetString("Name");
//Test if the object has sources (and is therefore an object of interest.)
//TODO: improve this method
bool isActiveObject = container.ItemExists("SourceCount");
bool hasInputs = container.Chunks.Where(C => C.Name == "param_input").Count() > 0;
bool hasOutputs = container.Chunks.Where(C => C.Name == "param_output").Count() > 0;
bool isComponent = hasInputs || hasOutputs;
Console.WriteLine(isComponent.ToString());
Node node = new Node();
node.Type = typeGuid.ToString();
node.InstanceGuid = instanceGuid;
cg.Nodes.Add(node);
}
return cg;
}
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);
}
//Actual constructor for use in the program
public static CommonGraph CommonGraphFromGHFile(string file)
{
CommonGraph cg = new CommonGraph();
//construct GH Archive object for XML Traversal
GH_Archive archive = new GH_Archive();
archive.ReadFromFile(file);
MetaData graphMetaData = new MetaData();
graphMetaData.Ignore = archive.Serialize_Xml();
cg.MetaData = graphMetaData;
//traverse GH file tree
var rootNode = archive.GetRootNode;
var definition = rootNode.FindChunk("Definition");
var defObjects = definition.FindChunk("DefinitionObjects");
int objCount = defObjects.GetInt32("ObjectCount");
//for every object in the definition object list:
for (int i = 0; i < objCount; i++)
{
var singleObjectChunk = defObjects.Chunks[i] as GH_Chunk;
Guid typeGuid = singleObjectChunk.GetGuid("GUID");
var container = singleObjectChunk.FindChunk("Container");
var attributes = container.FindChunk("Attributes");
Guid instanceGuid = container.GetGuid("InstanceGuid");
string name = singleObjectChunk.GetString("Name");
IEnumerable<GH_IChunk> inputs;
IEnumerable<GH_IChunk> outputs;
//Components that implement variable parameters store their inputs/outputs one layer deeper.
var parameterData = container.Chunks.Where<GH_IChunk>(C => C.Name == "ParameterData");
bool hasParameterData = parameterData.Count() > 0;
bool hasSourceCount = container.ItemExists("SourceCount");
var paramChunks = container.Chunks;
if (hasParameterData)
{
paramChunks = parameterData.ToList()[0].Chunks;
inputs = paramChunks.Where(C => C.Name == "InputParam");
outputs = paramChunks.Where(C => C.Name == "OutputParam");
}
else
{
inputs = paramChunks.Where(C => C.Name == "param_input");
outputs = paramChunks.Where(C => C.Name == "param_output");
}
bool hasInputs = inputs.Count() > 0;
bool hasOutputs = outputs.Count() > 0;
bool isComponent = hasInputs || hasOutputs || hasParameterData;
bool isActiveObject = isComponent || hasSourceCount;
//Debugging
//Console.WriteLine(name);
//Console.WriteLine("Is active object? " + isActiveObject.ToString());
//Console.WriteLine("Is Component? " + isComponent.ToString());
if (!isActiveObject) continue;
Node node = new Node();
//type and instance
node.Type = typeGuid.ToString();
node.InstanceGuid = instanceGuid.ToString();
node.Name = name;
Position pos = new Position();
try
{
var locPoint = attributes.GetDrawingPointF("Pivot");
pos.X = locPoint.X;
pos.Y = locPoint.Y;
}
catch { }
node.Position = pos;
//Metadata
MetaData md = new MetaData();
md.Ignore = chunkToXmlString(singleObjectChunk);
//TODO - REMOVE COMPONENTS OF XML THAT SHOULDN'T BE INSPECTED
md.Inspect = chunkToXmlString(singleObjectChunk);
node.MetaData = md;
List<Port> ports = new List<Port>();
List<Edge> edges = new List<Edge>();
if (isComponent) //if it's a component
{
List<GH_IChunk> portChunks = new List<GH_IChunk>();
portChunks.AddRange(inputs);
portChunks.AddRange(outputs);
foreach (var portIChunk in portChunks) // for every port "chunk"
{
Port port = new Port();
GH_Chunk portChunk = portIChunk as GH_Chunk;
Guid portInstanceGuid = portChunk.GetGuid("InstanceGuid");
port.InstanceGuid = portInstanceGuid.ToString();
port.Name = portChunk.GetString("Name");
MetaData portMetadata = new MetaData();
portMetadata.Ignore = chunkToXmlString(portChunk);
port.MetaData = portMetadata; //REMEMBER TO UNCOMMENT
ports.Add(port);
var sources = portChunk.Items.Where(item => item.Name == "Source");
//Console.WriteLine("WE GOT THIS MANY SOURCES:" +sources.Count());
foreach(GH_Item item in sources){
//Console.WriteLine("EDGE");
Edge edge = new Edge();
edge.DestGuid = portInstanceGuid.ToString();
edge.SrcGuid = item._guid.ToString();
edges.Add(edge);
}
}
}
else if(!isComponent && isActiveObject) //if it's a param
{
Port port = new Port();
//wrapper for object - if it's a param, instance for virtual node and port are the same.
Guid portInstanceGuid = instanceGuid;
port.InstanceGuid = instanceGuid.ToString();
port.Name = name;
ports.Add(port);
var sources = container.Items.Where(item => item.Name == "Source");
foreach (GH_Item source in sources)
{
Edge edge = new Edge();
edge.DestGuid = portInstanceGuid.ToString();
edge.SrcGuid = source._guid.ToString();
edges.Add(edge);
}
}
node.Ports = ports;
cg.Edges.AddRange(edges);
cg.Nodes.Add(node);
}
return cg;
}
//Actual constructor for use in the program
public static CommonGraph CommonGraphFromGHFile(string file)
{
CommonGraph cg = new CommonGraph();
//construct GH Archive object for XML Traversal
GH_Archive archive = new GH_Archive();
archive.ReadFromFile(file);
MetaData graphMetaData = new MetaData();
graphMetaData.Ignore = archive.Serialize_Xml();
cg.MetaData = graphMetaData;
//traverse GH file tree
var rootNode = archive.GetRootNode;
var definition = rootNode.FindChunk("Definition");
var defObjects = definition.FindChunk("DefinitionObjects");
int objCount = defObjects.GetInt32("ObjectCount");
//for every object in the definition object list:
for (int i = 0; i < objCount; i++)
{
var singleObjectChunk = defObjects.Chunks[i] as GH_Chunk;
Guid typeGuid = singleObjectChunk.GetGuid("GUID");
var container = singleObjectChunk.FindChunk("Container");
var attributes = container.FindChunk("Attributes");
Guid instanceGuid = container.GetGuid("InstanceGuid");
string name = singleObjectChunk.GetString("Name");
IEnumerable <GH_IChunk> inputs;
IEnumerable <GH_IChunk> outputs;
//Components that implement variable parameters store their inputs/outputs one layer deeper.
var parameterData = container.Chunks.Where <GH_IChunk>(C => C.Name == "ParameterData");
bool hasParameterData = parameterData.Count() > 0;
bool hasSourceCount = container.ItemExists("SourceCount");
var paramChunks = container.Chunks;
if (hasParameterData)
{
paramChunks = parameterData.ToList()[0].Chunks;
inputs = paramChunks.Where(C => C.Name == "InputParam");
outputs = paramChunks.Where(C => C.Name == "OutputParam");
}
else
{
inputs = paramChunks.Where(C => C.Name == "param_input");
outputs = paramChunks.Where(C => C.Name == "param_output");
}
bool hasInputs = inputs.Count() > 0;
bool hasOutputs = outputs.Count() > 0;
bool isComponent = hasInputs || hasOutputs || hasParameterData;
bool isActiveObject = isComponent || hasSourceCount;
//Debugging
//Console.WriteLine(name);
//Console.WriteLine("Is active object? " + isActiveObject.ToString());
//Console.WriteLine("Is Component? " + isComponent.ToString());
if (!isActiveObject)
{
continue;
}
Node node = new Node();
//type and instance
node.Type = typeGuid.ToString();
node.InstanceGuid = instanceGuid.ToString();
node.Name = name;
Position pos = new Position();
try
{
var locPoint = attributes.GetDrawingPointF("Pivot");
pos.X = locPoint.X;
pos.Y = locPoint.Y;
}
catch { }
node.Position = pos;
//Metadata
MetaData md = new MetaData();
md.Ignore = chunkToXmlString(singleObjectChunk);
//TODO - REMOVE COMPONENTS OF XML THAT SHOULDN'T BE INSPECTED
md.Inspect = chunkToXmlString(singleObjectChunk);
node.MetaData = md;
List <Port> ports = new List <Port>();
List <Edge> edges = new List <Edge>();
if (isComponent) //if it's a component
{
List <GH_IChunk> portChunks = new List <GH_IChunk>();
portChunks.AddRange(inputs);
portChunks.AddRange(outputs);
foreach (var portIChunk in portChunks) // for every port "chunk"
{
Port port = new Port();
GH_Chunk portChunk = portIChunk as GH_Chunk;
Guid portInstanceGuid = portChunk.GetGuid("InstanceGuid");
port.InstanceGuid = portInstanceGuid.ToString();
port.Name = portChunk.GetString("Name");
MetaData portMetadata = new MetaData();
portMetadata.Ignore = chunkToXmlString(portChunk);
port.MetaData = portMetadata; //REMEMBER TO UNCOMMENT
ports.Add(port);
var sources = portChunk.Items.Where(item => item.Name == "Source");
//Console.WriteLine("WE GOT THIS MANY SOURCES:" +sources.Count());
foreach (GH_Item item in sources)
{
//Console.WriteLine("EDGE");
Edge edge = new Edge();
edge.DestGuid = portInstanceGuid.ToString();
edge.SrcGuid = item._guid.ToString();
edges.Add(edge);
}
}
}
else if (!isComponent && isActiveObject) //if it's a param
{
Port port = new Port();
//wrapper for object - if it's a param, instance for virtual node and port are the same.
Guid portInstanceGuid = instanceGuid;
port.InstanceGuid = instanceGuid.ToString();
port.Name = name;
ports.Add(port);
var sources = container.Items.Where(item => item.Name == "Source");
foreach (GH_Item source in sources)
{
Edge edge = new Edge();
edge.DestGuid = portInstanceGuid.ToString();
edge.SrcGuid = source._guid.ToString();
edges.Add(edge);
}
}
node.Ports = ports;
cg.Edges.AddRange(edges);
cg.Nodes.Add(node);
}
return(cg);
}
// Start is called before the first frame update
void Start()
{
client = new RestClient(serviceUrl);
archive = new GH_Archive();
archive.ReadFromFile(Application.streamingAssetsPath + "\\" + ghFile);
var root = archive.GetRootNode;
var def = root.FindChunk("Definition") as GH_Chunk;
var objs = def.FindChunk("DefinitionObjects") as GH_Chunk;
if (objs != null)
{
int count = objs.GetInt32("ObjectCount");
var inputGuids = new List <Guid>();
var inputNames = new List <string>();
for (int i = 0; i < count; i++)
{
var obj = objs.FindChunk("Object", i) as GH_Chunk;
var container = obj.FindChunk("Container") as GH_Chunk;
var name = container.GetString("Name");
if (name == "Group")
{
var nickname = container.GetString("NickName");
if (nickname.IndexOf("RH_IN:") != -1)
{
var inputname = nickname.Replace("RH_IN:", "");
var itemguid = container.GetGuid("ID", 0);
inputNames.Add(inputname);
inputGuids.Add(itemguid);
}
}
}
for (int i = 0; i < count; i++)
{
var obj = objs.FindChunk("Object", i) as GH_Chunk;
var container = obj.FindChunk("Container") as GH_Chunk;
var instanceguid = container.GetGuid("InstanceGuid");
if (inputGuids.Contains(instanceguid))
{
var index = inputGuids.IndexOf(instanceguid);
var inputName = inputNames[index];
var componetName = container.GetString("Name");
object value = null;
switch (componetName)
{
case ("Point"):
value = new float[] { 0.5f, 0.5f, 0.5f };
break;
case ("Number"):
value = 0.5f;
break;
case ("Integer"):
value = 10;
break;
default:
break;
}
var ghInput = new GHInput(componetName, inputName, value);
ghInputs.Add(ghInput);
}
}
}
SendGHData();
}
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;
}
