protected override bool Read(Rhino.FileIO.BinaryArchiveReader archive)
{
Rhino.Collections.ArchivableDictionary dict = archive.ReadDictionary();
object ho = base.ReadHotLoadData(dict);
if (dict.ContainsKey("alpha"))
{
alpha = (int)dict["alpha"];
}
if (dict.ContainsKey("beta"))
{
beta = (double)dict["beta"];
}
if (dict.ContainsKey("classA"))
{
classA = JsonConvert.DeserializeObject <TestClassA>(dict.GetString("classA"));
}
if (dict.ContainsKey("classB"))
{
classB = JsonConvert.DeserializeObject <TestClassB>(dict.GetString("classB"));
}
if (dict.ContainsKey("classC"))
{
classC = JsonConvert.DeserializeObject <TestClassC>(dict.GetString("classC"));
}
//if (dict.ContainsKey("classD")) classD = JsonConvert.DeserializeObject<TestClassD>(dict.GetString("classD"));
if (dict.ContainsKey("classE"))
{
classE = JsonConvert.DeserializeObject <TestClassE>(dict.GetString("classE"));
}
return(true);
}
protected override bool Read(Rhino.FileIO.BinaryArchiveReader archive)
{
Rhino.Collections.ArchivableDictionary dict = archive.ReadDictionary();
Beam ownerBeam = ProjectPlugIn.Instance.Beams.Find(o => o.Id == dict.GetInteger("BeamId"));
BaseBrep = (Brep)dict["baseBrep"];
int noBaseCurves = dict.GetInteger("NoBaseCurves");
for (int i = 0; i < noBaseCurves; i++)
{
BaseCurves.Add((Curve)dict["BaseCurve" + i]);
}
Id = (int)dict["Id"];
if ((string)dict["Material"] == "Concrete")
{
Material = new ConcreteMaterial((string)dict["MaterialStrength"], ownerBeam);
}
else if ((string)dict["Material"] == "Steel")
{
Material = new SteelMaterial((string)dict["MaterialName"], SteelType.StructuralSteel, ownerBeam);
}
//TODO Add extra materials
else
{
Material = new ConcreteMaterial("C30/37", ownerBeam);
}
return(true);
}
protected override bool Read(Rhino.FileIO.BinaryArchiveReader archive)
{
Rhino.Collections.ArchivableDictionary dict = archive.ReadDictionary();
int i = 0;
while (dict.ContainsKey("geoSeg" + i))
{
Brep brep = (Brep)dict["gsBrep" + i];
Material material;
if (dict[$"gsMaterial{i}"] == "Concrete")
{
material = new ConcreteMaterial((string)dict[$"gsMaterialStrength{i}"]);
GeometrySegments.Add(new GeometrySegment(brep, material));
}
else if (dict[$"gsMaterial{i}"] == "Steel")
{
material = new SteelMaterial((string)dict[$"gsMaterialName{i}"]);
GeometrySegments.Add(new GeometrySegment(brep, material));
}
//TODO Add extra materials
else
{
material = new ConcreteMaterial("C30/37");
GeometrySegments.Add(new GeometrySegment(brep, material));
}
i++;
}
return(true);
}
protected override void WriteDocument(RhinoDoc doc, BinaryArchiveWriter archive, FileWriteOptions options)
{
var dict = new Rhino.Collections.ArchivableDictionary(1, "RigiBodyData");
//If user save during animation, save the shapes at the time when start was pressed
if (!TimePanel.Instance.Restarted || TimePanel.Instance.TrackbarValue != 0)
{
List <RigidBody> copyToAdd = new List <RigidBody>();;
for (int i = 0; i < RigidBodyManager.World.RigidBodies.Count; i++)
{
copyToAdd.Add(RigidBodyManager.DuplicateRigidBody(RigidBodyManager.FramesRigidBodies[0][i], RigidBodyManager.FramesRigidBodies[0][i].IsStatic));
}
dict.Set("rigidBodies", RigidBodyManager.ObjectToByteArray(copyToAdd));
}
else
{
dict.Set("rigidBodies", RigidBodyManager.ObjectToByteArray(RigidBodyManager.RigidBodies));
}
dict.Set("guidList", RigidBodyManager.ObjectToByteArray(RigidBodyManager.GuidList));
dict.Set("geometryList", RigidBodyManager.ObjectToByteArray(RigidBodyManager.GeometryList));
dict.Set("MaxFrameBoxValue", (int)TimePanel.Instance.MaxFrameBoxValue);
dict.Set("worldCount", RigidBodyManager.World.RigidBodies.Count);
archive.WriteDictionary(dict);
}
protected override bool Write(Rhino.FileIO.BinaryArchiveWriter archive)
{
var dict = new Rhino.Collections.ArchivableDictionary(20171031, "Values");
int i = 0;
foreach (GeometrySegment geoSeg in GeometrySegments)
{
dict.Set("geoSeg" + i, i);
dict.Set("gsBrep" + i, geoSeg.BrepGeometry);
if (geoSeg.Material.GetType() == typeof(ConcreteMaterial))
{
ConcreteMaterial material = geoSeg.Material as ConcreteMaterial;
dict.Set("gsMaterial" + i, "Concrete");
dict.Set("gsMaterialStrength" + i, material.StrenghtClass);
}
else if (geoSeg.Material.GetType() == typeof(SteelMaterial))
{
SteelMaterial material = geoSeg.Material as SteelMaterial;
dict.Set("gsMaterial" + i, "Steel");
dict.Set("gsMaterialName" + i, material.Name);
}
i++;
}
archive.WriteDictionary(dict);
return(true);
}
protected override bool Write(Rhino.FileIO.BinaryArchiveWriter archive)
{
Rhino.Collections.ArchivableDictionary dict = new Rhino.Collections.ArchivableDictionary(1, "IgnorantCustomClass");
base.WriteHotLoadData(dict);
return(true);
}
protected override bool Read(Rhino.FileIO.BinaryArchiveReader archive)
{
Rhino.Collections.ArchivableDictionary dict = archive.ReadDictionary();
object ho = base.ReadHotLoadData(dict);
return(true);
}
protected DictHelper(SerializationInfo info, StreamingContext context)
{
Type t = typeof(Rhino.Collections.ArchivableDictionary);
var constructor = t.GetConstructor(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance,
null, new Type[] { typeof(SerializationInfo), typeof(StreamingContext) }, null);
SerializedDictionary = constructor.Invoke(new object[] { info, context }) as Rhino.Collections.ArchivableDictionary;
}
/// <summary>
/// Get the Values of The ColorGradient UserDictionary.
/// </summary>
/// <param name="Cloud">Input PointCloud</param>
/// <returns></returns>
public static List <double> Get_ColorValues(PointCloud Cloud)
{
Rhino.Collections.ArchivableDictionary ColorDict = (Rhino.Collections.ArchivableDictionary)Cloud.UserDictionary["ColorGradient"];
List <double> Values = new List <double>();
Values.AddRange((List <double>)ColorDict["Val"]);
return(Values);
}
protected bool WriteHotLoadData(Rhino.Collections.ArchivableDictionary dict)
{
string encAss = GenerateCSharpCode(this.GetType());
dict.Set("EncodedAssembly", encAss);
dict.Set("Type", this.GetType().FullName);
return(true);
}
/// <summary>
/// Clones the user data.
/// </summary>
/// <param name="source">The source data.</param>
protected override void OnDuplicate(UserData source)
{
UserDictionary dict = source as UserDictionary;
if (dict != null)
{
m_dictionary = dict.m_dictionary.Clone();
m_dictionary.SetParentUserData(this);
}
}
protected override bool Read(Rhino.FileIO.BinaryArchiveReader archive)
{
Rhino.Collections.ArchivableDictionary dict = archive.ReadDictionary();
if (dict.ContainsKey("IntegerData") && dict.ContainsKey("StringData"))
{
IntegerData = (int)dict["IntegerData"];
StringData = dict["StringData"] as String;
}
return(true);
}
public override bool SaveObject(RhinoDoc doc, RhinoObject doc_object, ref Transform transform, BinaryArchiveWriter archive)
{
string name = doc_object.Name;
Rhino.Collections.ArchivableDictionary userdata = doc_object.UserDictionary;
userdata.Set("ObjName", name);
archive.WriteDictionary(userdata);
return(!archive.WriteErrorOccured);
}
protected override void ReadDocument(RhinoDoc doc, BinaryArchiveReader archive, FileReadOptions options)
{
RigidBodyManager.World = new World(new CollisionSystemSAP());
Rhino.Collections.ArchivableDictionary dict = archive.ReadDictionary();
RigidBodyManager.GuidList = (List <Guid>)RigidBodyManager.ByteArrayToObject(dict["guidList"] as byte[]);
RigidBodyManager.RigidBodies = (List <RigidBody>)RigidBodyManager.ByteArrayToObject(dict["rigidBodies"] as byte[]);
RigidBodyManager.GeometryList = (List <Brep>)RigidBodyManager.ByteArrayToObject(dict["geometryList"] as byte[]);
TimePanel.Instance.MaxFrameBoxValue = (int)dict["MaxFrameBoxValue"];
//Reset
TimePanel.Instance.ResetNotSavable();
WorldCount = (int)dict["worldCount"];
}
public override bool RestoreObject(RhinoDoc doc, RhinoObject doc_object, ref Transform transform, BinaryArchiveReader archive)
{
Rhino.Collections.ArchivableDictionary userdata = archive.ReadDictionary();
string name = "";
if (userdata.TryGetString("ObjName", out name))
{
doc_object.Attributes.Name = name;
doc_object.CommitChanges();
}
return(!archive.ReadErrorOccured);
}
protected override bool Read(Rhino.FileIO.BinaryArchiveReader archive)
{
Rhino.Collections.ArchivableDictionary dict = archive.ReadDictionary();
BasePoint = (Point3d)dict["Point"];
OutLine = (Curve)dict["OutLine"];
Diameter = (int)dict["Diameter"];
double fyk = (double)dict["MaterialStrength"];
//TODO add a coorect material assignment
Material = new SteelMaterial((string)dict["MaterialName"]);
return(true);
}
protected override bool Write(Rhino.FileIO.BinaryArchiveWriter archive)
{
Rhino.Collections.ArchivableDictionary dict = new Rhino.Collections.ArchivableDictionary(1, "CustomDataClass");
base.WriteHotLoadData(dict);
dict.Set("alpha", alpha);
dict.Set("beta", beta);
dict.Set("classA", JsonConvert.SerializeObject(classA, Formatting.Indented));
dict.Set("classB", JsonConvert.SerializeObject(classB, Formatting.Indented));
dict.Set("classC", JsonConvert.SerializeObject(classC, Formatting.Indented));
dict.Set("classD", JsonConvert.SerializeObject(classD, Formatting.Indented));
dict.Set("classE", JsonConvert.SerializeObject(classE, Formatting.Indented));
archive.WriteDictionary(dict);
return(true);
}
protected override bool Write(Rhino.FileIO.BinaryArchiveWriter archive)
{
// you can implement File IO however you want... but the dictionary class makes
// issues like versioning in the 3dm file a bit easier. If you didn't want to use
// the dictionary for writing, your code would look something like.
//
// archive.Write3dmChunkVersion(1, 0);
// archive.WriteInt(Weight);
// archive.WriteDouble(Density);
var dict = new Rhino.Collections.ArchivableDictionary(1, "Physical");
dict.Set("Weight", Weight);
dict.Set("Density", Density);
archive.WriteDictionary(dict);
return true;
}
protected override bool Write(Rhino.FileIO.BinaryArchiveWriter archive)
{
// you can implement File IO however you want... but the dictionary class makes
// issues like versioning in the 3dm file a bit easier. If you didn't want to use
// the dictionary for writing, your code would look something like.
//
// archive.Write3dmChunkVersion(1, 0);
// archive.WriteInt(IntegerData);
// archive.WriteString(StringData);
var dict = new Rhino.Collections.ArchivableDictionary(1, "MyCustomData");
dict.Set("IntegerData", IntegerData);
dict.Set("StringData", StringData);
archive.WriteDictionary(dict);
return true;
}
protected override bool Write(Rhino.FileIO.BinaryArchiveWriter archive)
{
// you can implement File IO however you want... but the dictionary class makes
// issues like versioning in the 3dm file a bit easier. If you didn't want to use
// the dictionary for writing, your code would look something like.
//
// archive.Write3dmChunkVersion(1, 0);
// archive.WriteInt(IntegerData);
// archive.WriteString(StringData);
var dict = new Rhino.Collections.ArchivableDictionary(1, "MyCustomData");
dict.Set("IntegerData", IntegerData);
dict.Set("StringData", StringData);
archive.WriteDictionary(dict);
return(true);
}
/// <summary>
/// Set UserDictionry of Cloud for ColorGradient Used.
/// </summary>
public static void Set_ColorGradient_Dict(ref PointCloud Cloud, List <Color> Colors, List <double> ColorValues)
{
List <double> R = new List <double>();
List <double> G = new List <double>();
List <double> B = new List <double>();
foreach (Color color in Colors)
{
R.Add(color.R);
G.Add(color.G);
B.Add(color.B);
}
Rhino.Collections.ArchivableDictionary ColorDict = new Rhino.Collections.ArchivableDictionary();
ColorDict.Set("R", R);
ColorDict.Set("G", G);
ColorDict.Set("B", B);
ColorDict.Set("Val", ColorValues);
Cloud.UserDictionary.Set("ColorGradient", ColorDict);
}
/// <summary>
/// Get the Colors of The ColorGradient UserDictionary.
/// </summary>
/// <param name="Cloud">Input PointCloud</param>
/// <returns></returns>
public static List <Color> Get_Colors(PointCloud Cloud)
{
Rhino.Collections.ArchivableDictionary ColorDict = (Rhino.Collections.ArchivableDictionary)Cloud.UserDictionary["ColorGradient"];
List <double> Rl = new List <double>();
List <double> Gl = new List <double>();
List <double> Bl = new List <double>();
Rl.AddRange((List <double>)ColorDict["R"]);
Gl.AddRange((List <double>)ColorDict["G"]);
Bl.AddRange((List <double>)ColorDict["B"]);
List <Color> Colors = new List <Color>();
for (int i = 0; i < Rl.Count; i++)
{
Color color = Color.FromArgb((int)Rl[i], (int)Gl[i], (int)Bl[i]);
Colors.Add(color);
}
return(Colors);
}
public void JSONToUD(string JSON)
{
dynamic obj = JsonConvert.DeserializeObject <ExpandoObject>(JSON);
//Rhino.DocObjects.Custom.UserDictionary UD = new Rhino.DocObjects.Custom.UserDictionary();
Rhino.Collections.ArchivableDictionary initDict = new Rhino.Collections.ArchivableDictionary();
//Rhino.Collections.ArchivableDictionary dict = SelectedObject.Attributes.UserDictionary;
//Rhino.RhinoApp.WriteLine(obj)
IterateThroughJSON(obj, initDict);
//dict.Set(obj.Key, initDict);
///////// Find selected Object(s) /////////
var oes = new ObjectEnumeratorSettings
{
SelectedObjectsFilter = true,
IncludeLights = false,
IncludeGrips = false,
IncludePhantoms = false
};
List <RhinoObject> objs = RhinoDoc.ActiveDoc.Objects.GetObjectList(oes).ToList();
foreach (RhinoObject rhObj in objs)
{
Rhino.Collections.ArchivableDictionary dict = rhObj.Attributes.UserDictionary;
dict.Set(obj.Key, initDict);
rhObj.Geometry.UserDictionary.Set("sxbuilder", dict);
rhObj.Geometry.SetUserString("sxbuilder", "true");
}
//SelectedObject.Geometry.UserData.
//SelectedObject.Geometry.UserDictionary.
}
protected override bool Write(Rhino.FileIO.BinaryArchiveWriter archive)
{
var dict = new Rhino.Collections.ArchivableDictionary(20181023, "Values");
dict.Set("baseBrep", BaseBrep);
dict.Set("Id", Id);
if (OwnerBeam != null)
{
dict.Set("BeamId", OwnerBeam.Id);
}
else
{
dict.Set("BeamId", -1);
}
dict.Set("NoBaseCurves", BaseCurves.Count);
for (int i = 0; i < BaseCurves.Count; i++)
{
dict.Set("BaseCurve" + i, BaseCurves[i]);
}
if (Material.GetType() == typeof(ConcreteMaterial))
{
ConcreteMaterial material = Material as ConcreteMaterial;
dict.Set("Material", "Concrete");
dict.Set("MaterialStrength", material.StrengthClass);
}
else if (Material.GetType() == typeof(SteelMaterial))
{
SteelMaterial material = Material as SteelMaterial;
dict.Set("Material", "Steel");
dict.Set("MaterialName", material.StrengthClass);
}
archive.WriteDictionary(dict);
return(true);
}
protected object ReadHotLoadData(Rhino.Collections.ArchivableDictionary dict)
{
string encAss = "";
string type = "";
if (dict.ContainsKey("EncodedAssembly"))
{
encAss = dict.GetString("EncodedAssembly");
}
if (dict.ContainsKey("Type"))
{
type = dict.GetString("Type");
}
byte[] assByt = Convert.FromBase64String(encAss);
string tempPath = Path.GetTempFileName();
File.WriteAllBytes(tempPath, assByt);
Assembly assembly = Assembly.LoadFrom(tempPath);
Type t = assembly.GetType(type);
object instanceOfMyType = Activator.CreateInstance(t);
return(instanceOfMyType);
}
protected override bool Write(Rhino.FileIO.BinaryArchiveWriter archive)
{
var dict = new Rhino.Collections.ArchivableDictionary(20171031, "Values");
dict.Set("Point", BasePoint);
dict.Set("OutLine", OutLine);
dict.Set("Diameter", _diameter);
if (Material is SteelMaterial material)
{
dict.Set("MaterialName", material.Name);
}
else
{
dict.Set("MaterialName", "B500B");
RhinoApp.WriteLine("No material was assigned to reinforcement.");
}
archive.WriteDictionary(dict);
return(true);
}
/// <summary>
/// Clones the user data.
/// </summary>
/// <param name="source">The source data.</param>
protected override void OnDuplicate(UserData source)
{
UserDictionary dict = source as UserDictionary;
if (dict != null)
{
m_dictionary = dict.m_dictionary.Clone();
m_dictionary.SetParentUserData(this);
}
}
public DictHelper(Rhino.Collections.ArchivableDictionary d)
{
SerializedDictionary = d;
}
/// <summary>
/// Is called to read this entity.
/// </summary>
/// <param name="archive">An archive.</param>
/// <returns>Always returns true.</returns>
protected override bool Read(FileIO.BinaryArchiveReader archive)
{
m_dictionary = archive.ReadDictionary();
return true;
}
public static Rh.Collections.ArchivableDictionary Evaluate(string script,
Rh.Collections.ArchivableDictionary input,
string[] outputNames)
{
var py = Rh.Runtime.PythonScript.Create();
foreach (var kv in input)
{
py.SetVariable(kv.Key, kv.Value);
}
if (!script.Equals(_previousScript))
{
// Don't allow certain words in the script to attempt to avoid
// malicious attacks
string[] badwords = { "exec", "Assembly", "GetType", "Activator", "GetMethod", "GetPropert" };
foreach (var word in badwords)
{
if (script.IndexOf(word) >= 0)
{
throw new Exception($"Script is not allowed to contain the word {word}");
}
}
// validate that only Rhino namespaces are imported
const string import = "import ";
int importIndex = script.IndexOf(import);
while (importIndex >= 0)
{
importIndex += import.Length;
while (importIndex < script.Length)
{
char c = script[importIndex];
if (c == ' ')
{
importIndex++;
continue;
}
break;
}
if (script.IndexOf("Rhino", importIndex) != importIndex && script.IndexOf("rhinoscript", importIndex) != importIndex)
{
throw new Exception("Attempt to import module that is not permitted");
}
int commaAndContinuationIndex = script.IndexOfAny(new char[] { ',', '\\' }, importIndex);
if (commaAndContinuationIndex > 0)
{
int newlineIndex = script.IndexOf('\n', importIndex);
if (commaAndContinuationIndex < newlineIndex)
{
throw new Exception("Do not import multiple packages with a single import statement");
}
}
importIndex = script.IndexOf(import, importIndex);
}
_previousCompile = py.Compile(script);
_previousScript = script;
}
_previousCompile.Execute(py);
var rc = new Rh.Collections.ArchivableDictionary();
foreach (var name in outputNames)
{
rc[name] = py.GetVariable(name);
}
return(rc);
}
public void IterateThroughJSON(dynamic myObj, Rhino.Collections.ArchivableDictionary myDict)
{
if (((IDictionary <String, object>)myObj).ContainsKey("children"))
{
Rhino.RhinoApp.WriteLine("is Folder");
//myDict.Set(myObj.Key)
List <object> myObjChildrenKeys = new List <object>();
for (int i = 0; i < myObj.children.Count; i++)
{
myObjChildrenKeys.Add(myObj.children[i].Key);
dynamic kvp = myObj.children[i];
System.Collections.ArrayList arrayList = new System.Collections.ArrayList(myObjChildrenKeys);
int first = arrayList.IndexOf(kvp.Key.ToString());
int last = arrayList.LastIndexOf(kvp.Key.ToString());
//Rhino.RhinoApp.WriteLine(first.ToString(), "thatsmyobj");
if (((IDictionary <String, object>)kvp).ContainsKey("children"))
{
Rhino.Collections.ArchivableDictionary newDict = new Rhino.Collections.ArchivableDictionary();
if (first != -1 && first != last)
{
Rhino.RhinoApp.WriteLine("found it!");
myDict.Set(kvp.Key + " (at index " + i + ")", newDict);
}
else
{
myDict.Set(kvp.Key, newDict);
}
IterateThroughJSON(kvp, newDict);
}
else
{
if (kvp.Key == "Id")
{
Rhino.RhinoApp.WriteLine(kvp.Value);
Guid myGuid = new Guid(kvp.Value);
RhinoObject foundObject = Rhino.RhinoDoc.ActiveDoc.Objects.Find(myGuid);
myDict.Set("Geometry", foundObject.Geometry);
}
else
{
if (first != -1 && first != last)
{
Rhino.RhinoApp.WriteLine("found it!");
myDict.Set(kvp.Key + " (at index " + i + ")", kvp.Value);
}
else
{
myDict.Set(kvp.Key, kvp.Value);
}
}
}
}
}
else // no children
{
Rhino.RhinoApp.WriteLine(myObj.Value);
myDict.Set(myObj.Key, myObj.Value);
}
}
public static void Add(this Rhino.Collections.ArchivableDictionary d, System.Object obj)
{
}
/// <summary>
/// Clones the user data.
/// </summary>
/// <param name="source">The source data.</param>
protected override void OnDuplicate(UserData source)
{
UserDictionary dict = source as UserDictionary;
if (dict != null)
m_dictionary = dict.m_dictionary.Clone();
}
/// <summary>
/// Is called to read this entity.
/// </summary>
/// <param name="archive">An archive.</param>
/// <returns>Always returns true.</returns>
protected override bool Read(FileIO.BinaryArchiveReader archive)
{
m_dictionary = archive.ReadDictionary();
return(true);
}
