public void UpdateOutputStructure( )
{
List <SpeckleLayer> toRemove, toAdd, toUpdate;
toRemove = new List <SpeckleLayer>(); toAdd = new List <SpeckleLayer>(); toUpdate = new List <SpeckleLayer>();
SpeckleLayer.DiffLayerLists(GetLayers(), Layers, ref toRemove, ref toAdd, ref toUpdate);
foreach (SpeckleLayer layer in toRemove)
{
var myparam = Params.Output.FirstOrDefault(item => { return(item.Name == layer.Guid); });
if (myparam != null)
{
Params.UnregisterOutputParameter(myparam);
}
}
foreach (var layer in toAdd)
{
Param_GenericObject newParam = getGhParameter(layer);
Params.RegisterOutputParam(newParam, ( int )layer.OrderIndex);
}
foreach (var layer in toUpdate)
{
var myparam = Params.Output.FirstOrDefault(item => { return(item.Name == layer.Guid); });
myparam.NickName = layer.Name;
}
Params.OnParametersChanged();
}
public void DiffStructure(List <SpeckleLayer> newLayers)
{
dynamic diffResult = SpeckleLayer.DiffLayers(GetLayers(), newLayers);
foreach (SpeckleLayer layer in diffResult.toRemove)
{
var myparam = Params.Output.FirstOrDefault(item => { return(item.Name == layer.Uuid.ToString()); });
if (myparam != null)
{
Params.UnregisterOutputParameter(myparam);
}
}
foreach (var layer in diffResult.toAdd)
{
Param_GenericObject newParam = GetGhParameter(layer);
Params.RegisterOutputParam(newParam, layer.orderIndex);
}
foreach (var layer in diffResult.toUpdate)
{
var myparam = Params.Output.FirstOrDefault(item => { return(item.Name == layer.guid); });
myparam.NickName = layer.name;
}
Params.OnParametersChanged();
}
private Param_GenericObject getGhParameter(SpeckleLayer param)
{
Param_GenericObject newParam = new Param_GenericObject();
newParam.Name = ( string )param.Guid;
newParam.NickName = ( string )param.Name;
newParam.MutableNickName = false;
newParam.Access = GH_ParamAccess.tree;
return(newParam);
}
private Param_GenericObject GetGhParameter(SpeckleLayer param)
{
Param_GenericObject newParam = new Param_GenericObject()
{
Name = param.Uuid.ToString(),
NickName = param.Name,
MutableNickName = false,
Access = GH_ParamAccess.tree
};
return(newParam);
}
public void BakeLayer(string layerId)
{
SpeckleLayer myLayer = Client.Stream.Layers.FirstOrDefault(l => l.Guid == layerId);
// create or get parent
string parent = String.Format("{1} | {0}", Client.Stream.StreamId, Client.Stream.Name);
var parentId = Rhino.RhinoDoc.ActiveDoc.Layers.FindByFullPath(parent, true);
if (parentId == -1)
{
var parentLayer = new Layer()
{
Color = System.Drawing.Color.Black,
Name = parent
};
parentId = Rhino.RhinoDoc.ActiveDoc.Layers.Add(parentLayer);
}
else
{
int prev = Rhino.RhinoDoc.ActiveDoc.Layers.FindByFullPath(parent + "::" + myLayer.Name, true);
if (prev != -1)
{
Rhino.RhinoDoc.ActiveDoc.Layers.Purge(prev, true);
}
}
int theLayerId = Rhino.RhinoDoc.ActiveDoc.Layers.FindByFullPath(parent + "::" + myLayer.Name, true);
if (theLayerId == -1)
{
var layer = new Layer()
{
Name = myLayer.Name,
Id = Guid.Parse(myLayer.Guid),
ParentLayerId = Rhino.RhinoDoc.ActiveDoc.Layers[parentId].Id,
Color = GetColorFromLayer(myLayer),
IsVisible = true
};
var index = Rhino.RhinoDoc.ActiveDoc.Layers.Add(layer);
for (int i = ( int )myLayer.StartIndex; i < myLayer.StartIndex + myLayer.ObjectCount; i++)
{
if (Display.Geometry[i] != null)
{
Rhino.RhinoDoc.ActiveDoc.Objects.Add(Display.Geometry[i], new ObjectAttributes()
{
LayerIndex = index
});
}
}
}
Rhino.RhinoDoc.ActiveDoc?.Views.Redraw();
}
public void ToggleLayerVisibility(string layerId, bool status)
{
SpeckleLayer myLayer = Client.Stream.Layers.FirstOrDefault(l => l.Guid == layerId);
if (myLayer == null)
{
throw new Exception("Bloopers. Layer not found.");
}
for (int i = ( int )myLayer.StartIndex; i < myLayer.StartIndex + myLayer.ObjectCount; i++)
{
Display.VisibleList[i] = status;
}
Rhino.RhinoDoc.ActiveDoc?.Views.Redraw();
}
public System.Drawing.Color GetColorFromLayer(SpeckleLayer layer)
{
System.Drawing.Color layerColor = System.Drawing.ColorTranslator.FromHtml("#AEECFD");
try
{
if (layer != null && layer.Properties != null)
{
layerColor = System.Drawing.ColorTranslator.FromHtml(layer.Properties.Color.Hex);
}
}
catch
{
Debug.WriteLine("Layer '{0}' had no assigned color", layer.Name);
}
return(layerColor);
}
public void ToggleLayerHover(string layerId, bool status)
{
SpeckleLayer myLayer = Client.Stream.Layers.FirstOrDefault(l => l.Guid == layerId);
if (myLayer == null)
{
throw new Exception("Bloopers. Layer not found.");
}
if (status)
{
Display.HoverRange = new Interval(( double )myLayer.StartIndex, ( double )(myLayer.StartIndex + myLayer.ObjectCount));
}
else
{
Display.HoverRange = null;
}
Rhino.RhinoDoc.ActiveDoc?.Views.Redraw();
}
public List <SpeckleLayer> GetLayers()
{
List <SpeckleLayer> layers = new List <SpeckleLayer>();
int startIndex = 0;
int count = 0;
foreach (IGH_Param myParam in Params.Output)
{
// NOTE: For gh receivers, we store the original guid of the sender component layer inside the parametr name.
SpeckleLayer myLayer = new SpeckleLayer(
myParam.NickName,
Guid.Parse(myParam.Name) /* aka the orignal guid*/, GetTopology(myParam),
myParam.VolatileDataCount,
startIndex,
count);
layers.Add(myLayer);
startIndex += myParam.VolatileDataCount;
count++;
}
return(layers);
}
public List <SpeckleLayer> getLayers()
{
List <SpeckleLayer> layers = new List <SpeckleLayer>();
int startIndex = 0;
int count = 0;
foreach (IGH_Param myParam in Params.Input)
{
SpeckleLayer myLayer = new SpeckleLayer(
myParam.NickName,
myParam.InstanceGuid.ToString(),
getTopology(myParam),
myParam.VolatileDataCount,
startIndex,
count);
layers.Add(myLayer);
startIndex += myParam.VolatileDataCount;
count++;
}
return(layers);
}
// TODO: This method, or an abstracted version of it, should move to Speckle Core.
public async void SendStaggeredUpdate(bool force = false)
{
if (Paused && !force)
{
Context.NotifySpeckleFrame("client-expired", StreamId, "");
return;
}
if (IsSendingUpdate)
{
Expired = true;
return;
}
IsSendingUpdate = true;
Context.NotifySpeckleFrame("client-is-loading", StreamId, "");
var objs = RhinoDoc.ActiveDoc.Objects.FindByUserString("spk_" + this.StreamId, "*", false).OrderBy(obj => obj.Attributes.LayerIndex);
Context.NotifySpeckleFrame("client-progress-message", StreamId, "Converting " + objs.Count() + " objects...");
List <SpeckleLayer> pLayers = new List <SpeckleLayer>();
List <SpeckleObject> convertedObjects = new List <SpeckleObject>();
List <PayloadMultipleObjects> objectUpdatePayloads = new List <PayloadMultipleObjects>();
long totalBucketSize = 0;
long currentBucketSize = 0;
List <SpeckleObject> currentBucketObjects = new List <SpeckleObject>();
List <SpeckleObject> allObjects = new List <SpeckleObject>();
int lindex = -1, count = 0, orderIndex = 0;
foreach (RhinoObject obj in objs)
{
// layer list creation
Layer layer = RhinoDoc.ActiveDoc.Layers[obj.Attributes.LayerIndex];
if (lindex != obj.Attributes.LayerIndex)
{
var spkLayer = new SpeckleLayer()
{
Name = layer.FullPath,
Guid = layer.Id.ToString(),
ObjectCount = 1,
StartIndex = count,
OrderIndex = orderIndex++,
Properties = new SpeckleLayerProperties()
{
Color = new SpeckleCore.Color()
{
A = 1, Hex = System.Drawing.ColorTranslator.ToHtml(layer.Color)
},
}
};
pLayers.Add(spkLayer);
lindex = obj.Attributes.LayerIndex;
}
else
{
var spkl = pLayers.FirstOrDefault(pl => pl.Name == layer.FullPath);
spkl.ObjectCount++;
}
count++;
// object conversion
SpeckleObject convertedObject;
convertedObject = Converter.Serialise(obj.Geometry);
convertedObject.ApplicationId = obj.Id.ToString();
allObjects.Add(convertedObject);
Context.NotifySpeckleFrame("client-progress-message", StreamId, "Converted " + count + " objects out of " + objs.Count() + ".");
// check cache and see what the response from the server is when sending placeholders
// in the ObjectCreateBulkAsyncRoute
if (Context.SpeckleObjectCache.ContainsKey(convertedObject.Hash))
{
convertedObject = new SpeckleObjectPlaceholder()
{
Hash = convertedObject.Hash, DatabaseId = Context.SpeckleObjectCache[convertedObject.Hash].DatabaseId, ApplicationId = Context.SpeckleObjectCache[convertedObject.Hash].ApplicationId
};
}
// size checking & bulk object creation payloads creation
long size = Converter.getBytes(convertedObject).Length;
currentBucketSize += size;
totalBucketSize += size;
currentBucketObjects.Add(convertedObject);
if (currentBucketSize > 2e6)
{
// means we're around fooking bazillion mb of an upload. FAIL FAIL FAIL
Context.NotifySpeckleFrame("client-error", StreamId, JsonConvert.SerializeObject("This stream contains a super big object. These are not supported yet :("));
Context.NotifySpeckleFrame("client-done-loading", StreamId, "");
IsSendingUpdate = false;
return;
}
if (currentBucketSize > 5e5) // restrict max to ~500kb; should it be user config? anyway these functions should go into core. at one point.
{
Debug.WriteLine("Reached payload limit. Making a new one, current #: " + objectUpdatePayloads.Count);
objectUpdatePayloads.Add(new PayloadMultipleObjects()
{
Objects = currentBucketObjects.ToArray()
});
currentBucketObjects = new List <SpeckleObject>();
currentBucketSize = 0;
}
// catch overflows early
if (totalBucketSize >= 50e6)
{
Context.NotifySpeckleFrame("client-error", StreamId, JsonConvert.SerializeObject("This is a humongous update, in the range of ~50mb. For now, create more streams instead of just one massive one! Updates will be faster and snappier, and you can combine them back together at the other end easier. " + totalBucketSize / 1000 + "(kb)"));
IsSendingUpdate = false;
Context.NotifySpeckleFrame("client-done-loading", StreamId, "");
return;
}
}
// last bucket
if (currentBucketObjects.Count > 0)
{
objectUpdatePayloads.Add(new PayloadMultipleObjects()
{
Objects = currentBucketObjects.ToArray()
});
}
Debug.WriteLine("Finished, payload object update count is: " + objectUpdatePayloads.Count + " total bucket size is (kb) " + totalBucketSize / 1000);
if (objectUpdatePayloads.Count > 100 || totalBucketSize >= 50e6)
{
// means we're around fooking bazillion mb of an upload. FAIL FAIL FAIL
Context.NotifySpeckleFrame("client-error", StreamId, JsonConvert.SerializeObject("This is a humongous update, in the range of ~50mb. For now, create more streams instead of just one massive one! Updates will be faster and snappier, and you can combine them back together at the other end easier. " + totalBucketSize / 1000 + "(kb)"));
IsSendingUpdate = false;
Context.NotifySpeckleFrame("client-done-loading", StreamId, "");
return;
}
// create bulk object creation tasks
int k = 0;
List <ResponsePostObjects> responses = new List <ResponsePostObjects>();
foreach (var payload in objectUpdatePayloads)
{
Context.NotifySpeckleFrame("client-progress-message", StreamId, String.Format("Sending payload {0} out of {1}", k++, objectUpdatePayloads.Count));
try
{
responses.Add(await Client.ObjectCreateBulkAsync(payload));
}
catch (Exception err)
{
Context.NotifySpeckleFrame("client-error", Client.Stream.StreamId, JsonConvert.SerializeObject(err.Message));
Context.NotifySpeckleFrame("client-done-loading", StreamId, "");
IsSendingUpdate = false;
return;
}
}
Context.NotifySpeckleFrame("client-progress-message", StreamId, "Updating stream...");
// finalise layer creation
foreach (var layer in pLayers)
{
layer.Topology = "0-" + layer.ObjectCount + " ";
}
// create placeholders for stream update payload
List <SpeckleObjectPlaceholder> placeholders = new List <SpeckleObjectPlaceholder>();
int m = 0;
foreach (var myResponse in responses)
{
foreach (string dbId in myResponse.Objects)
{
placeholders.Add(new SpeckleObjectPlaceholder()
{
DatabaseId = dbId, ApplicationId = allObjects[m++].ApplicationId
});
}
}
// create stream update payload
PayloadStreamUpdate streamUpdatePayload = new PayloadStreamUpdate();
streamUpdatePayload.Layers = pLayers;
streamUpdatePayload.Objects = placeholders;
streamUpdatePayload.Name = Client.Stream.Name;
// set some base properties (will be overwritten)
var baseProps = new Dictionary <string, object>();
baseProps["units"] = RhinoDoc.ActiveDoc.ModelUnitSystem.ToString();
baseProps["tolerance"] = RhinoDoc.ActiveDoc.ModelAbsoluteTolerance;
baseProps["angleTolerance"] = RhinoDoc.ActiveDoc.ModelAngleToleranceRadians;
streamUpdatePayload.BaseProperties = baseProps;
// push it to the server yo!
ResponseStreamUpdate response = null;
try
{
response = await Client.StreamUpdateAsync(streamUpdatePayload, Client.Stream.StreamId);
}
catch (Exception err)
{
Context.NotifySpeckleFrame("client-error", Client.Stream.StreamId, JsonConvert.SerializeObject(err.Message));
IsSendingUpdate = false;
return;
}
// put the objects in the cache
int l = 0;
foreach (var obj in streamUpdatePayload.Objects)
{
obj.DatabaseId = response.Objects[l];
Context.SpeckleObjectCache[allObjects[l].Hash] = placeholders[l];
l++;
}
// emit events, etc.
Client.Stream.Layers = streamUpdatePayload.Layers.ToList();
Client.Stream.Objects = streamUpdatePayload.Objects.Select(o => o.ApplicationId).ToList();
Context.NotifySpeckleFrame("client-metadata-update", StreamId, Client.Stream.ToJson());
Context.NotifySpeckleFrame("client-done-loading", StreamId, "");
Client.BroadcastMessage(new { eventType = "update-global" });
IsSendingUpdate = false;
if (Expired)
{
DataSender.Start();
}
Expired = false;
}
