/// <summary>
/// Sort the internal images.
/// </summary>
/// <param name="method">Specifies the sorting method.</param>
/// <returns>If the sorting is successful, <i>true</i> is returned, otherwise <i>false</i> is returned.</returns>
/// <remarks>NOTE: Sorting only applies to the images currently loaded.</remarks>
public bool Sort(IMGDB_SORT method)
{
if (method == IMGDB_SORT.BYID)
{
m_rgImages = m_rgImages.OrderBy(p => p.ImageID).ToArray();
}
else if (method == IMGDB_SORT.BYID_DESC)
{
m_rgImages = m_rgImages.OrderByDescending(p => p.ImageID).ToArray();
}
else if (method == IMGDB_SORT.BYIDX)
{
m_rgImages = m_rgImages.OrderBy(p => p.Index).ToArray();
}
else if (method == IMGDB_SORT.BYDESC)
{
m_rgImages = m_rgImages.OrderBy(p => p.Description).ToArray();
}
else if (method == IMGDB_SORT.BYTIME)
{
m_rgImages = m_rgImages.OrderBy(p => p.TimeStamp).ToArray();
}
else if ((method & (IMGDB_SORT.BYDESC | IMGDB_SORT.BYTIME)) == (IMGDB_SORT.BYDESC | IMGDB_SORT.BYTIME))
{
m_rgImages = m_rgImages.OrderBy(p => p.Description).ThenBy(p => p.TimeStamp).ToArray();
}
else
{
return(false);
}
return(true);
}
/// <summary>
/// The constructor used to copy another MasterIndexes and optionally specify a sorting for the indexes.
/// </summary>
/// <param name="idx">Specifies the MasterIndexes to copy.</param>
/// <param name="sort">Optionally, specifies a sorting to use on the indexes.</param>
public MasterIndexes(MasterIndexes idx, IMGDB_SORT sort)
{
m_sort = sort;
m_src = idx.m_src;
m_random = idx.m_random;
m_nLoadLimit = idx.m_nLoadLimit;
m_factory = new DatasetFactory(idx.m_factory);
m_index = idx.m_index.Clone(sort);
m_rgLabels = new LabelIndex(idx.m_rgLabels);
m_boosted = idx.m_boosted.Clone(sort);
m_rgLabelsBoosted = new LabelIndex(idx.m_rgLabelsBoosted);
}
public Index Clone(IMGDB_SORT sort = IMGDB_SORT.NONE)
{
List <DbItem> rgItems = new List <DbItem>();
for (int i = 0; i < m_rgItems.Count; i++)
{
rgItems.Add(m_rgItems[i].Clone());
}
switch (sort)
{
case IMGDB_SORT.BYID:
rgItems = rgItems.OrderBy(p => p.ID).ToList();
break;
case IMGDB_SORT.BYID_DESC:
rgItems = rgItems.OrderByDescending(p => p.ID).ToList();
break;
case IMGDB_SORT.BYIDX:
rgItems = rgItems.OrderBy(p => p.Index).ToList();
break;
case IMGDB_SORT.BYDESC:
rgItems = rgItems.OrderBy(p => p.Desc).ThenBy(p => p.Index).ToList();
break;
case IMGDB_SORT.BYTIME:
rgItems = rgItems.OrderBy(p => p.Time).ToList();
break;
default:
if ((sort & (IMGDB_SORT.BYDESC | IMGDB_SORT.BYTIME)) == (IMGDB_SORT.BYDESC | IMGDB_SORT.BYTIME))
{
rgItems = rgItems.OrderBy(p => p.Desc).ThenBy(p => p.Time).ToList();
}
break;
}
return(new Index(m_strName + " copy", m_random, rgItems, m_nLabel, m_bBoosted, m_dfProbability));
}
/// <summary>
/// Create a new QueryState and optionally sort the results.
/// </summary>
/// <param name="bUseUniqueLabelIndexes">Optionally, specifies to use unique label indexes which is slightly slower, but ensures each label is hit per epoch equally (default = true).</param>
/// <param name="bUseUniqueImageIndexes">Optionally, specifies to use unique image indexes which is slightly slower, but ensures each image is hit per epoch (default = true).</param>
/// <param name="sort">Optionally, specifies a sorting method for the query set.</param>
/// <returns>The new QueryState is returned.</returns>
public QueryState CreateQueryState(bool bUseUniqueLabelIndexes = true, bool bUseUniqueImageIndexes = true, IMGDB_SORT sort = IMGDB_SORT.NONE)
{
return(new QueryState(m_masterIdx, bUseUniqueLabelIndexes, bUseUniqueImageIndexes, sort));
}
/// <summary>
/// Create a new QueryState on the dataset.
/// </summary>
/// <param name="bUseUniqueLabelIndexes">Optionally, specifies to use unique label indexes which is slightly slower, but ensures each label is hit per epoch (default = true).</param>
/// <param name="bUseUniqueImageIndexes">Optionally, specifies to use unique image indexes which is slightly slower, but ensures each image is hit per epoch (default = true).</param>
/// <param name="sort">Optionally, specifies an ordering for the query state (default = NONE).</param>
/// <returns>The new query state is returned.</returns>
public long CreateQueryState(bool bUseUniqueLabelIndexes = true, bool bUseUniqueImageIndexes = true, IMGDB_SORT sort = IMGDB_SORT.NONE)
{
QueryState qsTraining = m_TrainingImages.CreateQueryState(bUseUniqueLabelIndexes, bUseUniqueImageIndexes, sort);
QueryState qsTesting = m_TestingImages.CreateQueryState(bUseUniqueLabelIndexes, bUseUniqueImageIndexes, sort);
return(m_queryStates.CreateNewState(qsTraining, qsTesting));
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="master">Specifies the MasterIndexes to copy.</param>
/// <param name="bUseUniqueLabelIndexes">Optionally, specifies to use unique label indexes which is slightly slower, but ensures each label is hit per epoch equally (default = true).</param>
/// <param name="bUseUniqueImageIndexes">Optionally, specifies to use unique image indexes which is slightly slower, but ensures each image is hit per epoch (default = true).</param>
/// <param name="sort">Optionally, specifies the ordering to use on the indexes (default = BYIDX).</param>
public QueryState(MasterIndexes master, bool bUseUniqueLabelIndexes = true, bool bUseUniqueImageIndexes = true, IMGDB_SORT sort = IMGDB_SORT.BYIDX) : base(master, sort)
{
m_master = master;
m_stat = new LabelStats(master.LabelCount);
m_bUseUniqueLabelIndexes = bUseUniqueLabelIndexes;
m_bUseUniqueImageIndexes = bUseUniqueImageIndexes;
foreach (LabelDescriptor label in m_src.Labels)
{
m_stat.Add(label);
}
}
/// <summary>
/// Create a new query state, optionally with a certain sorting.
/// </summary>
/// <param name="strDs">Specifies the dataset on which to create the query state.</param>
/// <param name="bUseUniqueLabelIndexes">Optionally, specifies to use unique label indexes which is slightly slower, but ensures each label is hit per epoch (default = true).</param>
/// <param name="bUseUniqueImageIndexes">Optionally, specifies to use unique image indexes which is slightly slower, but ensures each image is hit per epoch (default = true).</param>
/// <param name="sort">Specifies the sorting method, if any.</param>
/// <returns>The query state is returned.</returns>
public long CreateQueryState(string strDs, bool bUseUniqueLabelIndexes = true, bool bUseUniqueImageIndexes = true, IMGDB_SORT sort = IMGDB_SORT.NONE)
{
lock (m_syncObj)
{
foreach (DatasetEx2 ds in m_rgDatasets)
{
if (ds.DatasetName == strDs)
{
return(ds.CreateQueryState(bUseUniqueLabelIndexes, bUseUniqueImageIndexes, sort));
}
}
throw new Exception("Failed to create a new query state for dataset = '" + strDs + "'.");
}
}
/// <summary>
/// Create a new query state, optionally with a certain sorting.
/// </summary>
/// <param name="nDsId">Specifies the dataset on which to create the query state.</param>
/// <param name="bUseUniqueLabelIndexes">Optionally, specifies to use unique label indexes which is slightly slower, but ensures each label is hit per epoch eually (default = true).</param>
/// <param name="bUseUniqueImageIndexes">Optionally, specifies to use unique image indexes which is slightly slower, but ensures each image is hit per epoch (default = true).</param>
/// <param name="sort">Specifies the sorting method, if any.</param>
/// <returns>The query state is returned.</returns>
public long CreateQueryState(int nDsId, bool bUseUniqueLabelIndexes = true, bool bUseUniqueImageIndexes = true, IMGDB_SORT sort = IMGDB_SORT.NONE)
{
lock (m_syncObj)
{
foreach (DatasetEx2 ds in m_rgDatasets)
{
if (ds.DatasetID == nDsId)
{
return(ds.CreateQueryState(bUseUniqueLabelIndexes, bUseUniqueImageIndexes, sort));
}
}
throw new Exception("Failed to create a new query state for dataset ID = " + nDsId.ToString() + ".");
}
}
