/// <summary>
/// Add a SubDataset to the list
/// </summary>
/// <param name="sd">The SubDataset to add</param>
/// <param name="updateID">Update the SubDataset ID or not</param>
public void AddSubDataset(SubDataset sd, bool updateID = true)
{
if (m_subDatasets.Contains(sd))
{
return;
}
if (updateID)
{
sd.ID = m_curSDID;
m_curSDID++;
}
m_subDatasets.Add(sd);
}
/// <summary>
/// Create a small multiple object
/// </summary>
/// <parent name="sd">The SubDataset to use</parent>
/// <returns>A VTKUnitySmallMultiple object.</returns>
public VTKUnitySmallMultiple CreatePointFieldSmallMultiple(SubDataset sd)
{
VTKUnitySmallMultiple sm = new VTKUnitySmallMultiple();
unsafe
{
if (sm.Init(m_dataset.Parser, sd, m_dimensions, m_dataProvider))
{
m_smallMultiples.Add(sm);
return(sm);
}
}
return(null);
}
/// <summary>
/// Remove a known small multiple from a subdataset
/// </summary>
/// <param name="sd">the subdataset to evaluate</param>
public void RemoveSmallMultipleFromSubDataset(SubDataset sd)
{
int i = 0;
while (i < m_smallMultiples.Count)
{
if (m_smallMultiples[i].SubDataset == sd)
{
m_smallMultiples.RemoveAt(i);
}
else
{
i++;
}
}
}
public virtual void OnLockOwnerIDChange(SubDataset dataset, int ownerID)
{
lock (this)
{
if (ownerID == -1)
{
m_updateOutlineColor = true;
m_outlineColor = Color.blue;
}
else
{
if (m_dataProvider != null)
{
m_updateOutlineColor = true;
m_outlineColor = m_dataProvider.GetHeadsetColor(ownerID);
}
}
}
}
public void Init(CloudPointDataset dataset, SubDataset sd, IDataProvider provider, bool isMiniature = false)
{
base.Init(sd, provider, isMiniature);
m_dataset = dataset;
//Init the mesh for better performance
m_mesh = new Mesh();
var layout = new[]
{
new VertexAttributeDescriptor(VertexAttribute.Position, VertexAttributeFormat.Float32, 3, 0),
new VertexAttributeDescriptor(VertexAttribute.Color, VertexAttributeFormat.UNorm8, 4, 1),
};
m_mesh.SetVertexBufferParams((int)dataset.NbPoints, layout);
if (m_dataset.NbPoints > 0xffff)
{
m_mesh.indexFormat = IndexFormat.UInt32;
}
UpdateTF();
}
public void SendAnchorAnnotation(SubDataset sd, float[] position)
{
byte[] data = new byte[2 + 2 * 4 + 3 * 4];
Int32 offset = 0;
//Type
WriteInt16(data, offset, (Int16)VFVSendCommand.SEND_ANCHOR_ANNOTATION);
offset += 2;
//DatasetID
WriteInt32(data, offset, sd.Parent.ID);
offset += 4;
//SubDataset ID
WriteInt32(data, offset, sd.ID);
offset += 4;
for (int i = 0; i < 3; i++, offset += sizeof(float))
{
WriteFloat(data, offset, position[i]);
}
Send(data);
}
public virtual void OnTransferFunctionChange(SubDataset dataset, TransferFunction tf)
{
}
public void OnLockOwnerIDChange(SubDataset dataset, int ownerID)
{
}
public virtual void OnOwnerIDChange(SubDataset dataset, int ownerID)
{
}
public override void OnChangeDepthClipping(SubDataset dataset, float minD, float maxD)
{
}
public void OnNameChange(SubDataset dataset, string name)
{
}
public virtual void OnChangeDepthClipping(SubDataset dataset, float minD, float maxDepth)
{
}
public void OnSetVisibility(SubDataset dataset, SubDatasetVisibility visibility)
{
}
public void OnAddLogAnnotationPosition(SubDataset dataset, LogAnnotationPositionInstance annot)
{
}
public void OnAddCanvasAnnotation(SubDataset dataset, CanvasAnnotation annot)
{
}
public void OnRemoveSubDataset(SubDatasetGroup sdg, SubDataset sd)
{
lock(this)
m_shouldRemoveConnections = true;
}
/// <summary>
/// Protected constructor
/// </summary>
/// <param name="data">The linked LogAnnotationComponent to use</param>
/// <param name="sd">The subdaatset owning this instance</param>
/// <param name="instanceID">The ID of this component</param>
protected LogAnnotationComponentInstance(LogAnnotationComponent data, SubDataset sd, Int32 instanceID)
{
m_data = data;
m_instanceID = instanceID;
m_sd = sd;
}
public void OnAddSubDataset(SubDatasetGroup sdg, SubDataset sd)
{}
private void Update()
{
lock(this)
{
if(m_shouldAddConnections)
{
foreach(var s in m_sdg.SubjectiveViews)
{
if(s.Key != null && !m_stacks.ContainsKey(s.Key))
AddStackConnection(s.Key);
if(s.Value != null && !m_links.ContainsKey(s.Value))
AddLinkConnection(s.Value);
}
m_shouldAddConnections = false;
m_shouldUpdatePos = true;
}
if(m_shouldRemoveConnections)
{
//Check every registered game objects. If one game object is no longer relevant --> delete it
bool found = true;
while (found)
{
found = false;
foreach (var s in m_links.Keys)
{
if (!m_sdg.SubDatasets.Contains(s))
{
Destroy(m_links[s]);
m_links.Remove(s);
found = true;
break;
}
}
}
found = true;
while (found)
{
found = false;
foreach (var s in m_stacks.Keys)
{
if (!m_sdg.SubDatasets.Contains(s))
{
Destroy(m_stacks[s]);
m_stacks.Remove(s);
found = true;
break;
}
}
}
m_shouldRemoveConnections = false;
m_shouldUpdatePos = true;
}
if(m_shouldUpdatePos)
{
if (m_sdg.StackMethod == StackMethod.STACK_VERTICAL)
{
foreach (var it in m_stacks)
{
it.Value.transform.localScale = new Vector3(it.Key.Scale[0], m_sdg.YVerticalGap, it.Key.Scale[2]);
it.Value.transform.position = new Vector3(it.Key.Position[0],
it.Key.Position[1] - (it.Key.Scale[1] + it.Value.transform.localScale[1])/2.0f,
it.Key.Position[2]);
}
}
else
{
foreach (var it in m_stacks)
it.Value.SetActive(false);
}
foreach(var it in m_links)
{
SubDataset stack = m_sdg.SubjectiveViews.Find(s => s.Value == it.Key).Key;
if (stack == null)
continue;
//Determine the best option for the link (shortest path)
Vector3 anchorPoint = new Vector3(it.Key.Position[0] + it.Key.Scale[0]/2.0f,
it.Key.Position[1] + it.Key.Scale[1]/2.0f,
it.Key.Position[2] + it.Key.Scale[2]/2.0f);
Vector3 targetPos = new Vector3(stack.Position[0] - stack.Scale[0]/2.0f,
stack.Position[1] - stack.Scale[1]/2.0f,
stack.Position[2] - stack.Scale[2]/2.0f);
float dist = (anchorPoint - targetPos).magnitude;
for(int i = -1; i <= 1; i+=2)
{
for(int j = -1; j <= 1; j+=2)
{
for(int k = -1; k <= 1; k+=2)
{
for (int ii = -1; ii <= 1; ii += 2)
{
for (int jj = -1; jj <= 1; jj += 2)
{
for (int kk = -1; kk <= 1; kk += 2)
{
Vector3 _anchorPoint = new Vector3(it.Key.Position[0] + i*it.Key.Scale[0] / 2.0f,
it.Key.Position[1] + j*it.Key.Scale[1] / 2.0f,
it.Key.Position[2] + k*it.Key.Scale[2] / 2.0f);
Vector3 _targetPos = new Vector3(stack.Position[0] + ii*stack.Scale[0] / 2.0f,
stack.Position[1] + jj*stack.Scale[1] / 2.0f,
stack.Position[2] + kk*stack.Scale[2] / 2.0f);
float _dist = (_anchorPoint - _targetPos).magnitude;
if(_dist < dist)
{
anchorPoint = _anchorPoint;
targetPos = _targetPos;
dist = _dist;
}
}
}
}
}
}
}
//Configure the position + orientation of the link object (cylinder)
Vector3 rayVec = targetPos - anchorPoint;
rayVec = rayVec.normalized;
Vector3 scale = it.Value.transform.localScale;
scale.x = 0.02f;
scale.z = 0.02f;
scale.y = (targetPos - anchorPoint).magnitude / 2.0f;
it.Value.transform.localScale = scale;
it.Value.transform.up = rayVec;
it.Value.transform.localPosition = anchorPoint + rayVec * it.Value.transform.localScale.y;
}
m_shouldUpdatePos = false;
}
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="container">Container which has loaded the values</param>
/// <param name="pos">The position data model</param>
/// <param name="sd">The subdaatset owning this instance</param>
/// <param name="instanceID">The ID of this object to link it to its attached object</param>
public LogAnnotationPositionInstance(LogAnnotationContainer container, LogAnnotationPosition pos, SubDataset sd, Int32 instanceID) : base(pos, sd, instanceID)
{
m_container = container;
m_data = pos;
}
public virtual void OnToggleMapVisibility(SubDataset dataset, bool visibility)
{
}
public void OnScaleChange(SubDataset dataset, float[] scale)
{
}
public virtual void OnChangeVolumetricMask(SubDataset dataset)
{
}
public override void OnOwnerIDChange(SubDataset dataset, int ownerID)
{
base.OnOwnerIDChange(dataset, ownerID);
UpdateTF();
}
public void OnSetSubDatasetGroup(SubDataset dataset, SubDatasetGroup sdg)
{
}
public override void OnChangeVolumetricMask(SubDataset dataset)
{
base.OnChangeVolumetricMask(dataset);
UpdateTF();
}
public void OnSetTFComputation(SubDataset dataset, object tfComputation)
{
}
public void OnClearCanvasAnnotations(SubDataset dataset)
{
}
public override void OnTransferFunctionChange(SubDataset dataset, TransferFunction tf)
{
base.OnTransferFunctionChange(dataset, tf);
UpdateTF();
}
public void OnPositionChange(SubDataset dataset, float[] position)
{
}
