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