示例#1
0
        public ImageDifferenceResultEnum TryCalculateCombinedDifference(byte differenceThreshold)
        {
            if (this.CurrentDifferenceState != ImageDifferenceEnum.Combined)
            {
                return(ImageDifferenceResultEnum.NotCalculable);
            }

            // We need three valid images: the current one, the previous one, and the next one.
            if (this.Current == null || this.Current.IsVideo || this.Current.IsDisplayable(this.Database.FolderPath) == false)
            {
                this.CurrentDifferenceState = ImageDifferenceEnum.Unaltered;
                return(ImageDifferenceResultEnum.CurrentImageNotAvailable);
            }

            if (this.TryGetPreviousBitmapAsWriteable(out WriteableBitmap previousBitmap) == false)
            {
                return(ImageDifferenceResultEnum.PreviousImageNotAvailable);
            }

            if (this.TryGetNextBitmapAsWriteable(out WriteableBitmap nextBitmap) == false)
            {
                return(ImageDifferenceResultEnum.NextImageNotAvailable);
            }

            WriteableBitmap unalteredBitmap = this.differenceBitmapCache[ImageDifferenceEnum.Unaltered].AsWriteable();

            this.differenceBitmapCache[ImageDifferenceEnum.Unaltered] = unalteredBitmap;

            // all three images are available, so calculate and cache difference
            BitmapSource differenceBitmap = unalteredBitmap.CombinedDifference(previousBitmap, nextBitmap, differenceThreshold);

            this.differenceBitmapCache[ImageDifferenceEnum.Combined] = differenceBitmap;
            return(differenceBitmap != null ? ImageDifferenceResultEnum.Success : ImageDifferenceResultEnum.NotCalculable);
        }
示例#2
0
 public ImageCache(FileDatabase fileDatabase) :
     base(fileDatabase)
 {
     this.TryMoveToFile(Constant.DatabaseValues.InvalidRow);
     this.CurrentDifferenceState = ImageDifferenceEnum.Unaltered;
     this.differenceBitmapCache  = new Dictionary <ImageDifferenceEnum, BitmapSource>();
     this.mostRecentlyUsedIDs    = new RecencyOrderedList <long>(Constant.ImageValues.BitmapCacheSize);
     this.prefetechesByID        = new ConcurrentDictionary <long, Task>();
     this.unalteredBitmapsByID   = new ConcurrentDictionary <long, BitmapSource>();
 }
示例#3
0
        public void MoveToNextStateInPreviousNextDifferenceCycle()
        {
            // If we are looking at the combined differenced image, then always go to the unaltered image.
            if (this.CurrentDifferenceState == ImageDifferenceEnum.Combined)
            {
                this.CurrentDifferenceState = ImageDifferenceEnum.Unaltered;
                return;
            }

            // If the current image is marked as corrupted, we will only show the original (replacement) image
            if (!this.Current.IsDisplayable(this.Database.FolderPath))
            {
                this.CurrentDifferenceState = ImageDifferenceEnum.Unaltered;
                return;
            }
            else
            {
                // We are going around in a cycle, so go back to the beginning if we are at the end of it.
                this.CurrentDifferenceState = (this.CurrentDifferenceState >= ImageDifferenceEnum.Next) ? ImageDifferenceEnum.Previous : ++this.CurrentDifferenceState;
            }

            // Because we can always display the unaltered image, we don't have to do any more tests if that is the current one in the cyle
            if (this.CurrentDifferenceState == ImageDifferenceEnum.Unaltered)
            {
                return;
            }

            // We can't actually show the previous or next image differencing if we are on the first or last image in the set respectively
            // Nor can we do it if the next image in the sequence is a corrupted one.
            // If that is the case, skip to the next one in the sequence
            if (this.CurrentDifferenceState == ImageDifferenceEnum.Previous && this.CurrentRow == 0)
            {
                // Already at the beginning
                this.MoveToNextStateInPreviousNextDifferenceCycle();
            }
            else if (this.CurrentDifferenceState == ImageDifferenceEnum.Next && this.CurrentRow == this.Database.CountAllCurrentlySelectedFiles - 1)
            {
                // Already at the end
                this.MoveToNextStateInPreviousNextDifferenceCycle();
            }
            else if (this.CurrentDifferenceState == ImageDifferenceEnum.Next && !this.Database.IsFileDisplayable(this.CurrentRow + 1))
            {
                // Can't use the next image as its corrupted
                this.MoveToNextStateInPreviousNextDifferenceCycle();
            }
            else if (this.CurrentDifferenceState == ImageDifferenceEnum.Previous && !this.Database.IsFileDisplayable(this.CurrentRow - 1))
            {
                // Can't use the previous image as its corrupted
                this.MoveToNextStateInPreviousNextDifferenceCycle();
            }
        }
示例#4
0
 public void MoveToNextStateInCombinedDifferenceCycle()
 {
     // if this method and MoveToNextStateInPreviousNextDifferenceCycle() returned bool they'd be consistent MoveNext() and MovePrevious()
     // however, there's no way for them to fail and there's not value in always returning true
     if (this.CurrentDifferenceState == ImageDifferenceEnum.Next ||
         this.CurrentDifferenceState == ImageDifferenceEnum.Previous ||
         this.CurrentDifferenceState == ImageDifferenceEnum.Combined)
     {
         this.CurrentDifferenceState = ImageDifferenceEnum.Unaltered;
     }
     else
     {
         this.CurrentDifferenceState = ImageDifferenceEnum.Combined;
     }
 }
示例#5
0
        public ImageDifferenceResultEnum TryCalculateDifference()
        {
            if (this.Current == null || this.Current.IsVideo || this.Current.IsDisplayable(this.Database.FolderPath) == false)
            {
                this.CurrentDifferenceState = ImageDifferenceEnum.Unaltered;
                return(ImageDifferenceResultEnum.CurrentImageNotAvailable);
            }

            // determine which image to use for differencing
            WriteableBitmap comparisonBitmap;

            if (this.CurrentDifferenceState == ImageDifferenceEnum.Previous)
            {
                if (this.TryGetPreviousBitmapAsWriteable(out comparisonBitmap) == false)
                {
                    return(ImageDifferenceResultEnum.PreviousImageNotAvailable);
                }
            }
            else if (this.CurrentDifferenceState == ImageDifferenceEnum.Next)
            {
                if (this.TryGetNextBitmapAsWriteable(out comparisonBitmap) == false)
                {
                    return(ImageDifferenceResultEnum.NextImageNotAvailable);
                }
            }
            else
            {
                return(ImageDifferenceResultEnum.NotCalculable);
            }

            WriteableBitmap unalteredBitmap = this.differenceBitmapCache[ImageDifferenceEnum.Unaltered].AsWriteable();

            this.differenceBitmapCache[ImageDifferenceEnum.Unaltered] = unalteredBitmap;

            BitmapSource differenceBitmap = unalteredBitmap.Subtract(comparisonBitmap);

            this.differenceBitmapCache[this.CurrentDifferenceState] = differenceBitmap;
            return(differenceBitmap != null ? ImageDifferenceResultEnum.Success : ImageDifferenceResultEnum.NotCalculable);
        }