private void FindClusterableContainers(ISourceTree element, string fullName)
{
if (element is IClusterable)
{
_clusterableContainers.Add((element, fullName));
}
}
public void AddDataSource(ISourceTree source)
{
_dataSources.Add(source);
var treeElement = Instantiate(TreeElementPrefab, SourceTreeView).GetComponent <SourceTreeElement>();
_roots.Add(treeElement);
treeElement.Node = source;
if (_roots.Count == 1)
{
treeElement.ChangeState();
}
if (source is IRemovable r)
{
r.OnRemoved += () =>
{
_dataSources.Remove(source);
Destroy(treeElement.gameObject);
};
}
// ReSharper disable once LocalVariableHidesMember
foreach (var renderer in _renderers)
{
source.SetRenderer(renderer);
}
OnSourceAdded?.Invoke(source);
}
private static void SubscribeOnConnectableContainer <TCloudItem>(this IDataRecorderPlugin recorder,
ISourceTree source,
string topicName)
where TCloudItem : struct, ICloudItem
{
var connectionsUpdatedName = nameof(IConnectableObjectsContainer <ICloudItem> .OnConnectionsUpdated);
var connectionsUpdated = Observable.FromEvent <EventHandler <ConnectionsEventArgs> >(
h => (sender, args) => recorder.OnConnectionsUpdated <TCloudItem>(topicName, args.Items.ToList()),
h => source.GetType().GetEvent(connectionsUpdatedName).AddEventHandler(source, h),
h => source.GetType().GetEvent(connectionsUpdatedName).RemoveEventHandler(source, h))
.Subscribe();
var connectionsRemovedName = nameof(IConnectableObjectsContainer <ICloudItem> .OnConnectionsRemoved);
var connectionsRemoved = Observable.FromEvent <EventHandler <ConnectionsEventArgs> >(
h => (sender, args) => recorder.OnConnectionsRemoved <TCloudItem>(topicName, args.Items.ToList()),
h => source.GetType().GetEvent(connectionsRemovedName).AddEventHandler(source, h),
h => source.GetType().GetEvent(connectionsRemovedName).RemoveEventHandler(source, h))
.Subscribe();
Subscriptions[recorder][source].Add(connectionsUpdated);
Subscriptions[recorder][source].Add(connectionsRemoved);
recorder.OnConnectionsUpdated <TCloudItem>(source.DisplayName, (source as IConnectableObjectsContainer <TCloudItem>)?
.Connections
.Select(l => (l.Point1.Id, l.Point2.Id))
.ToList());
recorder.SubscribeOnCloudContainer <TCloudItem>(source, topicName);
}
private static void MapSourceTree(ISourceTree treeElement, string path, Func <ISourceTree, string, bool> action)
{
var fullName = $"{path}/{treeElement.DisplayName}";
bool deeper = action(treeElement, fullName);
if (!deeper)
{
return;
}
foreach (var child in treeElement.Children)
{
MapSourceTree(child, fullName, action);
}
}
public static bool SubscribeOn(this IDataRecorderPlugin recorder, ISourceTree source, string topicName)
{
if (!Subscriptions.ContainsKey(recorder))
{
Subscriptions.Add(recorder, new Dictionary <ISourceTree, List <IDisposable> >());
}
if (Subscriptions[recorder].ContainsKey(source))
{
return(true);
}
Subscriptions[recorder].Add(source, new List <IDisposable>());
if (source is IRemovable r)
{
r.OnRemoved += () => recorder.UnsubscribeFrom(source);
}
var type = source.GetType()
.GetInterfaces()
.FirstOrDefault(x => x.IsGenericType &&
x.GetGenericTypeDefinition() == typeof(IConnectableObjectsContainer <>));
if (type != null)
{
typeof(DataRecorderSubscriber)
.GetMethod(nameof(SubscribeOnConnectableContainer),
BindingFlags.Static | BindingFlags.NonPublic)?
.MakeGenericMethod(type.GetGenericArguments()[0])
.Invoke(null, new object[] { recorder, source, topicName });
return(true);
}
type = source.GetType()
.GetInterfaces()
.FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IContainer <>));
if (type != null)
{
typeof(DataRecorderSubscriber)
.GetMethod(nameof(SubscribeOnCloudContainer), BindingFlags.Static | BindingFlags.NonPublic)?
.MakeGenericMethod(type.GetGenericArguments()[0])
.Invoke(null, new object[] { recorder, source, topicName });
return(true);
}
return(false);
}
public ProtobufContainerTree(string displayName, ISourceTree image, SlamDataInfoPresenter specialInfo = null)
{
DisplayName = displayName;
Image = image;
SpecialInfo = specialInfo;
TrackedObjs = new TrackedObjectsContainer("Tracked objects");
Observations = new ConnectableObjectsContainer <SlamObservation>(
new CloudContainer <SlamObservation>("Points"),
new SlamLinesContainer("Connections"),
"Observations");
Points = new ConnectableObjectsContainer <SlamPoint>(
new CloudContainer <SlamPoint>("Points"),
new SlamLinesContainer("Connections"),
"Points");
Connector = new Connector(Points, Observations, "Connections");
Lines = new SlamLinesContainer("Lines");
MeshContainer = new MeshReconstructor(Points, "Mesh");
InfinitePlanes = new CloudContainer <SlamInfinitePlane>("Infinite planes");
var observationsGraph = new VirtualContainer("Observations graph", new List <ISourceTree>
{
(ISourceTree)Observations,
Connector
});
var ch = new List <ISourceTree>
{
(ISourceTree)Points,
(ISourceTree)TrackedObjs,
(ISourceTree)InfinitePlanes,
observationsGraph,
(ISourceTree)Lines,
MeshContainer,
Image,
};
if (SpecialInfo != null)
{
ch.Add(SpecialInfo);
}
Children = ch.ToArray();
}
public ImageHandler(ISourceTree container, RosSocket socket, string topic) : base(container, socket, topic)
{
}
public void Start()
{
_node = GetComponent <SourceTreeElement>().Node;
// ReSharper disable once SuspiciousTypeConversion.Global
if (_node is IRendersToWindow rendersToWindow)
{
WindowButton.OnClickAsObservable().Subscribe(_ => rendersToWindow.Window.Show());
}
else
{
WindowButton.gameObject.SetActive(false);
}
if (_node is IVisible v)
{
VisibleButton.OnStateChanged += state => v.IsVisible = state == 0;
}
else
{
VisibleButton.gameObject.SetActive(false);
}
if (_node is ITraceable t)
{
TraceButton.OnStateChanged += state => t.TraceEnabled = state == 1;
}
else
{
TraceButton.gameObject.SetActive(false);
}
if (_node is IRemovable r)
{
RemoveButton.OnClickAsObservable().Subscribe(_ =>
{
r.RemoveSelf();
Destroy(gameObject);
});
}
else
{
RemoveButton.gameObject.SetActive(false);
}
if (Camera.main.GetComponent <LookableCamera>() is { } cam)
{
switch (_node)
{
case IFollowable <SlamTrackedObject> followable when _node is ILookable l:
FollowButton.OnStateChanged += state =>
{
if (state == 0)
{
followable.Unfollow();
}
else
{
cam.Look(l.Look(cam.transform));
followable.Follow();
}
};
LookAtButton.gameObject.SetActive(false);
break;
case ILookable lookable:
LookAtButton.OnClickAsObservable().Subscribe(_ => cam.Look(lookable.Look(cam.transform)));
FollowButton.gameObject.SetActive(false);
break;
default:
LookAtButton.gameObject.SetActive(false);
FollowButton.gameObject.SetActive(false);
break;
}
}
if (_node is ISave s)
{
SaveButton.OnClickAsObservable().Subscribe(_ => s.Save());
}
else
{
SaveButton.gameObject.SetActive(false);
}
if (_node is IWeightable w)
{
void SetMaxWeight(int value)
{
MaxWeightLabel.text = $"{value}";
WeightSlider.maxValue = value;
}
w.OnMaxWeightChanged += SetMaxWeight;
SetMaxWeight(w.MaxWeight);
WeightSlider.OnValueChangedAsObservable()
.Do(value => MinWeightLabel.text = $"{(int) value}")
.Subscribe(value => w.MinWeight = (int)value);
}
else
{
WeightButton.gameObject.SetActive(false);
}
}
public SceneManager(ISourceTree container)
{
_container = container;
}
protected MessageHandler(ISourceTree container, RosSocket socket, string topic)
{
_socket = socket;
Container = (TContainer)container;
_subscriptionId = _socket.Subscribe(topic, new SubscriptionHandler <TMessage>(Handle));
}
public static ICommand ToCommand(this Message message, ISourceTree container) => message switch
{
public PointCloud2Handler(ISourceTree container, RosSocket socket, string topic)
: base(container, socket, topic)
{
}
public PoseStampedHandler(ISourceTree container, RosSocket socket, string topic) : base(container, socket, topic)
{
}
public void AddChild(ISourceTree child)
{
ChildrenList.Add(child);
}
private static void SubscribeOnCloudContainer <TCloudItem>(this IDataRecorderPlugin recorder, ISourceTree source,
string topicName)
where TCloudItem : struct, ICloudItem
{
var addedName = nameof(IContainer <ICloudItem> .OnAdded);
var add = Observable.FromEvent <EventHandler <AddedEventArgs <TCloudItem> > >(
h => (sender, args) => recorder.OnAdded(topicName, args.AddedItems.ToList()),
h => source.GetType().GetEvent(addedName).AddEventHandler(source, h),
h => source.GetType().GetEvent(addedName).RemoveEventHandler(source, h))
.Subscribe();
var updatedName = nameof(IContainer <ICloudItem> .OnUpdated);
var updated = Observable.FromEvent <EventHandler <UpdatedEventArgs <TCloudItem> > >(
h => (sender, args) => recorder.OnUpdated(topicName, args.UpdatedItems.ToList()),
h => source.GetType().GetEvent(updatedName).AddEventHandler(source, h),
h => source.GetType().GetEvent(updatedName).RemoveEventHandler(source, h))
.Subscribe();
var removedName = nameof(IContainer <ICloudItem> .OnRemoved);
var removed = Observable.FromEvent <EventHandler <RemovedEventArgs> >(
h => (sender, args) => recorder.OnRemoved <TCloudItem>(topicName, args.RemovedIds.ToList()),
h => source.GetType().GetEvent(removedName).AddEventHandler(source, h),
h => source.GetType().GetEvent(removedName).RemoveEventHandler(source, h))
.Subscribe();
Subscriptions[recorder][source].Add(add);
Subscriptions[recorder][source].Add(updated);
Subscriptions[recorder][source].Add(removed);
recorder.OnAdded(source.DisplayName, (source as IContainer <TCloudItem>)?.ToList());
}
public static void UnsubscribeFrom(this IDataRecorderPlugin recorder, ISourceTree source)
{
}
