コード例 #1
0
        /// <summary>
        /// Initialize the ImageSet by creating the master list of images, starting its background image loading thread, and then creating the master index that maps the organization of the dataset.
        /// </summary>
        /// <param name="bSilentLoad">Specifies to load the data silently without status output.</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="nMaxLoadCount">Optionally, specifies to automaticall start the image refresh which only applies when the number of images loaded into memory is less than the actual number of images (default = false).</param>
        /// <returns>Once initialized, the default query state for the image set is returned.  This method may be called multiple times and each time returns a new QueryState.</returns>
        public QueryState Initialize(bool bSilentLoad, bool bUseUniqueLabelIndexes = true, bool bUseUniqueImageIndexes = true, int nMaxLoadCount = 0)
        {
            if (m_masterList == null)
            {
                m_masterList = new MasterList(m_random, m_log, m_src, m_factory, m_rgAbort, nMaxLoadCount);

                if (OnCalculateImageMean != null)
                {
                    m_masterList.OnCalculateImageMean += OnCalculateImageMean;
                }

                if (m_loadMethod == IMAGEDB_LOAD_METHOD.LOAD_ALL || m_loadMethod == IMAGEDB_LOAD_METHOD.LOAD_EXTERNAL || m_loadMethod == IMAGEDB_LOAD_METHOD.LOAD_ON_DEMAND_BACKGROUND)
                {
                    m_masterList.Load(bSilentLoad);
                }
            }

            if (m_masterIdx == null || m_masterIdx.LoadLimit != nMaxLoadCount)
            {
                m_masterIdx = new MasterIndexes(m_random, m_src, nMaxLoadCount);
            }

            QueryState state = new QueryState(m_masterIdx, bUseUniqueLabelIndexes, bUseUniqueImageIndexes);

            if (m_loadMethod == IMAGEDB_LOAD_METHOD.LOAD_ALL)
            {
                m_masterList.WaitForLoadingToComplete(m_rgAbort);
            }

            return(state);
        }
コード例 #2
0
ファイル: QueryState.cs プロジェクト: alllucky1996/MyCaffe
        /// <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);
            }
        }
コード例 #3
0
        /// <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);
        }
コード例 #4
0
        /// <summary>
        /// Releases the resouces used.
        /// </summary>
        /// <param name="bDisposing">Set to <i>true</i> when called by Dispose()</param>
        protected override void Dispose(bool bDisposing)
        {
            m_evtCancel.Set();

            if (m_masterIdx != null)
            {
                m_masterIdx.Dispose();
                m_masterIdx = null;
            }

            if (m_masterList != null)
            {
                m_masterList.Dispose();
                m_masterList = null;
            }

            base.Dispose(bDisposing);
        }
コード例 #5
0
ファイル: MasterList.cs プロジェクト: Flavio58it/MyCaffe
        /// <summary>
        /// Verify the loaded images against the master indexes.
        /// </summary>
        /// <param name="idx">Specifies the master indexes.</param>
        public void Verify(MasterIndexes idx)
        {
            if (idx.RawIndexes.Count != m_rgImages.Length)
            {
                throw new Exception("The index count should match the image count!");
            }

            List <int> rgObservedIdx = new List <int>();

            for (int i = 0; i < m_rgImages.Length; i++)
            {
                if (rgObservedIdx.Contains(m_rgImages[i].Index))
                {
                    throw new Exception("Duplicate image index found!  Your dataset may be corrupt.");
                }

                if (idx.RawIndexes[i].Index != m_rgImages[i].Index)
                {
                    throw new Exception("The image indexs do not match!  You may need to re-index the image list.");
                }

                rgObservedIdx.Add(m_rgImages[i].Index);
            }
        }