public void AddMarkup(MarkupBase zMarkup)
{
if (m_dictionaryTypeMarkupList.ContainsKey(zMarkup.GetType()))
{
m_dictionaryTypeMarkupList[zMarkup.GetType()].Add(zMarkup);
}
}
override protected Vector2 CalculateLabelPositionForMarkup(MarkupBase userMarkup)
{
if (!mystery && IsMarkupSelected(userMarkup))
{
return(ConvertPixelToLabel(ConvertUVToPixel(Cursor.localPosition)));
}
return(ConvertPixelToLabel(userMarkup.center));
}
override protected float ComputeScoreBetweenMarkup(MarkupBase userMarkup, MarkupBase gtMarkup)
{
Node userNode = userMarkup as Node;
if (userNode.IsHelper())
{
return(-1f);
} //stub
Node gtNode = gtMarkup as Node;
if (gtNode == null)
{
return(0);
} //???
int divideBy = userNode.neighbors.Count;
if (divideBy <= 0)
{
return(-1f);
} //stub
float linkScore = 0;
int gtCount = gtNode.neighbors.Count;
int badLinks = Math.Abs(divideBy - gtCount);
for (int i = 0; i < divideBy && i < gtCount; i++)
{
Node run = userNode.neighbors[i];
while (run != null && run.IsHelper())
{
run = run.neighbors[Math.Min(i, 1)];
}
bool matched = false;
foreach (Node gtnn in gtNode.neighbors)
{
if (DoesUserNodeMatchGTNode(run, gtnn))
{
matched = true;
}
}
if (!matched)
{
badLinks++;
}
}
linkScore = ((float)(divideBy - badLinks)) / ((float)divideBy);
float distScore = 1f - Vector3.Distance(userNode.center, gtNode.center) * distanceFactor;
return(Mathf.Max(linkScore, 0) * (1f - weightPos) + Mathf.Max(distScore, 0) * weightPos);
}
override protected float ComputeScoreBetweenMarkup(MarkupBase userMarkup, MarkupBase gtMarkup)
{
BlobData userBlob = userMarkup as BlobData;
BlobData closeBlob = gtMarkup as BlobData;
int csum = 0;
int errors = 0;
int examined = 0;
var ubpl = userBlob.pixels.Length;
for (int i = 0; i < closeBlob.pixels.Length; i++)
{
if (i >= ubpl)
{
continue;
}
examined++;
int ubp = userBlob.pixels[i];
int cbp = closeBlob.pixels[i];
if (ubp == 0 && cbp == 0)
{
continue;
}
if (cbp != 0 && ubp != 0)
{
csum++; continue;
}
if (cbp != 0)
{
csum++;
var cei = closeBlob.distIn[i];
if (cei > errorDeadzone)
{
errors += cei;
}
continue;
}
if (ubp != 0)
{
var ceo = closeBlob.distOut[i];
if (ceo > errorDeadzone)
{
errors += ceo;
}
continue;
}
}
return(Mathf.Max(0, 1f - ((float)errors / (float)csum) * errorFactor));
}
override protected MarkupBase ComputeClosestGTMarkup(MarkupBase userMarkup)
{
if (_groundTruthGraph == null)
{
return(null);
}
var closeMarkup = userMarkup;
var min = float.MaxValue;
foreach (var gtNode in _groundTruthGraph.nodes)
{
var dist = DistanceBetweenMarkups(userMarkup, gtNode);
if (dist < min)
{
min = dist;
closeMarkup = gtNode;
}
}
return(closeMarkup != userMarkup ? closeMarkup : null);
}
override protected MarkupBase ComputeClosestGTMarkup(MarkupBase userMarkup)
{
if (_groundTruthBlobs == null || _groundTruthBlobs.Values == null)
{
return(null);
}
//userBlob.center = GetWeightedBlobCenter( ref userBlob.pixels, _canvas.width );
MarkupBase closeMarkup = userMarkup;
float min = float.MaxValue;
foreach (var gtBlob in _groundTruthBlobs.Values)
{
float dist = DistanceBetweenMarkups(userMarkup, gtBlob);
if (dist < min)
{
min = dist;
closeMarkup = gtBlob;
}
}
return(closeMarkup != userMarkup ? closeMarkup : null);
}
override protected bool IsMarkupSelected(MarkupBase userMarkup)
{
return(GetBestGuessIndex() == (userMarkup as BlobData).index);
}
/// <summary>
/// Markup parser
/// </summary>
/// <param name="sInput"></param>
/// <returns></returns>
public static List <MarkupBase> GetMarkups(string sInput)
{
var listMarkups = new List <MarkupBase>();
var nIdx = 0;
var bEscapeNext = false;
var bInTag = false;
var bCloseTag = false;
var sTagName = string.Empty;
var sBuilder = new StringBuilder();
while (sInput.Length > nIdx)
{
if (bEscapeNext)
{
bEscapeNext = false;
switch (sInput[nIdx])
{
case '<':
case '>':
case '\\':
sBuilder.Append(sInput[nIdx]);
nIdx++;
continue;
default:
// append the missing \
sBuilder.Append("\\");
break;
}
}
var cCurrent = sInput[nIdx];
var cLast = nIdx > 0 ? sInput[nIdx - 1] : ' ';
switch (cCurrent)
{
case '\\':
if (!bInTag)
{
bEscapeNext = true;
}
else
{
sTagName += "\\";
}
break;
case '<':
if (!bInTag && sBuilder.Length > 0)
{
listMarkups.Add(new TextMarkup(sBuilder.ToString()));
}
bInTag = true;
sTagName = string.Empty;
sBuilder = new StringBuilder();
break;
case '>':
bInTag = false;
if (bCloseTag)
{
// find the tag to actually close
var zMarkupTypeToSeek = MarkupBase.GetMarkupType(sTagName);
if (null != zMarkupTypeToSeek)
{
for (int nMarkup = listMarkups.Count - 1; nMarkup > -1; nMarkup--)
{
if (listMarkups[nMarkup].GetType() == zMarkupTypeToSeek)
{
sTagName = string.Empty;
listMarkups.Add(new CloseTagMarkup(listMarkups[nMarkup]));
break;
}
}
}
bCloseTag = false;
// otherwise it is a junk markup, toss it out
}
else
{
var zMarkup = MarkupBase.GetMarkup(sTagName);
if (null != zMarkup)
{
// prevent continued adds of the same tag
sTagName = string.Empty;
listMarkups.Add(zMarkup);
}
}
break;
case ' ':
if (!bInTag && sBuilder.Length > 0)
{
listMarkups.Add(new TextMarkup(sBuilder.ToString()));
sBuilder = new StringBuilder();
}
if (bInTag)
{
sTagName += cCurrent;
}
else
{
if (listMarkups.Count == 0)
{
break;
}
var zMarkupBase = listMarkups[listMarkups.Count - 1];
if (!(zMarkupBase is SpaceMarkup))
{
// create a trimmable space (can be trimmed from end of line)
listMarkups.Add(new SpaceMarkup(true));
}
}
break;
default:
if (bInTag)
{
// this is just lazy, not checking if this is actually after the <
if ('/' == cCurrent && cLast == '<')
{
bCloseTag = true;
}
else
{
sTagName += cCurrent;
}
}
else
{
sBuilder.Append(cCurrent);
}
break;
}
nIdx++;
}
// trailing escape code char
if (bEscapeNext)
{
sBuilder.Append("\\");
}
if (!bInTag && sBuilder.Length > 0)
{
listMarkups.Add(new TextMarkup(sBuilder.ToString()));
}
return(listMarkups);
}
override protected bool IsMarkupSelected(MarkupBase userMarkup)
{
return(_dragging && _lastNode.node == userMarkup);
}
override protected Vector2 CalculateLabelPositionForMarkup(MarkupBase userMarkup)
{
return(ConvertPixelToLabel(ConvertUVToPixel(userMarkup.center - imageOffset)));
}
