DatasetExCollection.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MyCaffe.basecode;
 
namespace MyCaffe.db.image
{
    public class DatasetExCollection : IEnumerable<DatasetEx>, IDisposable
    {
        List<DatasetEx> m_rgDatasets = new List<DatasetEx>();
        bool m_bUseTrainingSourcesForTesting = false;
        ImageSet m_lastImgSet = null;
        object m_syncObj = new object();
 
        public DatasetExCollection()
        {
        }
 
        public bool RemoveDataset(DatasetEx ds)
        {
            return m_rgDatasets.Remove(ds);
        }
 
        public void RemoveCreatedDatasets()
        {
            List<int> rgIdx = new List<int>();
 
            for (int i = 0; i < m_rgDatasets.Count; i++)
            {
                if (m_rgDatasets[i].Descriptor.ID < 0)
                    rgIdx.Add(i);
            }
 
            for (int i = rgIdx.Count - 1; i >= 0; i--)
            {
                m_rgDatasets.RemoveAt(rgIdx[i]);
            }
        }
 
        public bool RemoveUser(Guid user)
        {
            bool bReleased = true;
 
            foreach (DatasetEx ds in m_rgDatasets)
            {
                if (ds.RemoveUser(user) > 0)
                    bReleased = false;
            }
 
            return bReleased;
        }
 
        public bool SaveImageMean(int nSrcID, SimpleDatum sd, bool bUpdate)
        {
            foreach (DatasetEx ds in m_rgDatasets)
            {
                if (ds.SaveImageMean(nSrcID, sd, bUpdate))
                    return true;
            }
 
            return false;
        }
 
        public SimpleDatum QueryImageMean(int nSrcID)
        {
            foreach (DatasetEx ds in m_rgDatasets)
            {
                SimpleDatum sd = ds.QueryImageMean(nSrcID);
                if (sd != null)
                    return sd;
            }
 
            return null;
        }
 
        public DatasetExCollection Clone()
        {
            DatasetExCollection col = new DatasetExCollection();
 
            col.m_bUseTrainingSourcesForTesting = m_bUseTrainingSourcesForTesting;
 
            foreach (DatasetEx ds in m_rgDatasets)
            {
                col.Add(ds.Clone());
            }
 
            return col;
        }
 
        public void Reset()
        {
            m_lastImgSet = null;
        }
 
        public void Relabel(LabelMappingCollection col)
        {
            foreach (DatasetEx ds in m_rgDatasets)
            {
                ds.Relabel(col);
            }
        }
 
        public int Count
        {
            get { return m_rgDatasets.Count; }
        }
 
        public void EnableUsingTrainingSourcesForTesting(bool bEnable)
        {
            m_bUseTrainingSourcesForTesting = bEnable;
 
            foreach (DatasetEx ds in m_rgDatasets)
            {
                ds.UseTrainingImagesForTesting = bEnable;
            }
        }
 
        public bool UseTrainingSourcesForTesting
        {
            get { return m_bUseTrainingSourcesForTesting; }
        }
 
        public DatasetEx this[int nIdx]
        {
            get { return m_rgDatasets[nIdx]; }
        }
 
        public DatasetEx FindDataset(int nDatasetID)
        {
            foreach (DatasetEx ds in m_rgDatasets)
            {
                if (ds.DatasetID == nDatasetID)
                    return ds;
            }
 
            return null;
        }
 
        public DatasetEx FindDataset(string strDs)
        {
            foreach (DatasetEx ds in m_rgDatasets)
            {
                if (ds.DatasetName == strDs)
                    return ds;
            }
 
            return null;
        }
 
        public ImageSet FindImageset(int nSourceID)
        {
            lock (m_syncObj)
            {
                if (m_lastImgSet != null && m_lastImgSet.SourceID == nSourceID)
                    return m_lastImgSet;
 
                foreach (DatasetEx ds in m_rgDatasets)
                {
                    ImageSet imgSet = ds.Find(nSourceID);
 
                    if (imgSet != null)
                    {
                        m_lastImgSet = imgSet;
                        return imgSet;
                    }
                }
 
                throw new Exception("Could not find source with ID = " + nSourceID.ToString() + "!");
            }
        }
 
        public ImageSet FindImageset(string strSource)
        {
            lock (m_syncObj)
            {
                if (m_lastImgSet != null && m_lastImgSet.SourceName == strSource)
                    return m_lastImgSet;
 
                foreach (DatasetEx ds in m_rgDatasets)
                {
                    ImageSet imgSet = ds.Find(strSource);
 
                    if (imgSet != null)
                    {
                        m_lastImgSet = imgSet;
                        return imgSet;
                    }
                }
 
                throw new Exception("Could not find source with Name = " + strSource + "!");
            }
        }
 
        public void Add(DatasetEx ds)
        {
            m_rgDatasets.Add(ds);
        }
 
        protected virtual void Dispose(bool bDisposing)
        {
            foreach (DatasetEx ds in m_rgDatasets)
            {
                ds.Dispose();
            }
 
            m_rgDatasets.Clear();
        }
 
        public void Dispose()
        {
            Dispose(true);
        }
 
        public IEnumerator<DatasetEx> GetEnumerator()
        {
            return m_rgDatasets.GetEnumerator();
        }
 
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return m_rgDatasets.GetEnumerator();
        }
    }
}