示例#1
0
        public void EncodeAndDecodeWithAPredictorAndBitOperationsPeppersBmpResultsTheSamePixels()
        {
            var aBasedPredictor = new ABasedPredictor();
            var paq6V2Archiver  = new Paq6V2Archiver();

            _gz2DlzEncoderFacade.InputFilePath     = _peppers512;
            _gz2DlzEncoderFacade.AbstractPredictor = aBasedPredictor;
            _gz2DlzEncoderFacade.ImageReader       = _bmpImageReader;
            _gz2DlzEncoderFacade.Archiver          = paq6V2Archiver;
            _encoder = new Gz2DlzEncoder(_gz2DlzEncoderFacade);

            var inputFilePath = _peppers512 + G2_2D_LZ.Helpers.Constants.Folder + Constants.Paq6Extension;

            gz2DlzDecoderFacade = new Gz2DlzDecoderFacade();
            gz2DlzDecoderFacade.InputFilePath     = inputFilePath;
            gz2DlzDecoderFacade.AbstractPredictor = aBasedPredictor;
            gz2DlzDecoderFacade.Archiver          = paq6V2Archiver;
            _decoder = new Gz2DlzDecoder(gz2DlzDecoderFacade);

            _encoder.Encode();
            _decoder.Decode();

            var workImage = _decoder.WorkImage;

            CompareValueWithPixelFromBmp(_peppers512, workImage);
        }
示例#2
0
        public void EncodeAndDecodeWithCalicPredictorCustomTxtLena256AnCreatesAFileIndenticalWithTheOriginal()
        {
            IImageReader txtImageReader = new TxtAsImageReader();

            _gz2DlzEncoderFacade.InputFilePath     = _lenna256anTxtFileName;
            _gz2DlzEncoderFacade.AbstractPredictor = new ABasedPredictor();
            _gz2DlzEncoderFacade.ImageReader       = txtImageReader;
            _gz2DlzEncoderFacade.Archiver          = new Paq6V2Archiver();
            _encoder = new Gz2DlzEncoder(_gz2DlzEncoderFacade);

            var inputFilePath = $"{_lenna256anTxtFileName}.mat";

            gz2DlzDecoderFacade = new Gz2DlzDecoderFacade();
            gz2DlzDecoderFacade.InputFilePath     = inputFilePath;
            gz2DlzDecoderFacade.AbstractPredictor = new ABasedPredictor();
            gz2DlzDecoderFacade.Archiver          = new Paq6V2Archiver();
            _decoder = new Gz2DlzDecoder(gz2DlzDecoderFacade);

            _encoder.Encode();
            _encoder.WriteMatrixToFileAsText();
            _decoder.LoadMatrixFromTxtFile();
            _decoder.Decode();
            _decoder.SaveOriginalImageAsTxtFile();

            var filename     = $"{_lenna256anTxtFileName}.mat.decoded.txt";
            var originalFile = GetContentWithoutNewLines(_lenna256anTxtFileName).Replace("256 256 ", "");
            var decodedFile  = GetContentWithoutNewLines(filename);

            Assert.AreEqual(originalFile.Length, decodedFile.Length);
            Assert.IsTrue(string.Equals(originalFile, decodedFile));
        }
        public void LocateTheBestAproximateMatchForGivenRootPixelGivesTheExpectedBestMatch()
        {
            _gz2DlzEncoderFacade.InputFilePath     = One3X4MatchBlockBmpPath;
            _gz2DlzEncoderFacade.AbstractPredictor = new ABasedPredictor();
            _gz2DlzEncoderFacade.ImageReader       = _bmpReader;
            _gz2DlzEncoderFacade.Archiver          = new Paq6V2Archiver();
            _encoder = new Gz2DlzEncoder(_gz2DlzEncoderFacade);

            var originalImage = _encoder.WorkImage;
            var width         = originalImage.GetLength(0);

            for (int i = 0; i < width; i++)
            {
                _encoder.IsPixelEncoded[0, i] = true;
                _encoder.IsPixelEncoded[1, i] = true;
                _encoder.IsPixelEncoded[2, i] = true;
                _encoder.IsPixelEncoded[3, i] = true;
                _encoder.IsPixelEncoded[4, i] = true;
            }
            for (int i = 0; i < 5; i++)
            {
                _encoder.IsPixelEncoded[0, i] = true;
            }

            var       encoderPosition = new PixelLocation(5, 5);
            var       rootPosition    = new PixelLocation(1, 1);
            BestMatch bestMatch       = _encoder.LocateTheBestAproximateMatchForGivenRootPixel(encoderPosition, rootPosition);

            Assert.AreEqual(4, bestMatch.Height);
            Assert.AreEqual(4, bestMatch.Width);
            Assert.AreEqual(16, bestMatch.Size);
        }
        public void EncodeFindsTheExpectedBlockMatchForVerticalMirrorTransform()
        {
            _gz2DlzEncoderFacade.InputFilePath           = VerticalMirrorBmpPath;
            _gz2DlzEncoderFacade.AbstractPredictor       = new ABasedPredictor();
            _gz2DlzEncoderFacade.ImageReader             = _bmpReader;
            _gz2DlzEncoderFacade.Archiver                = new Paq6V2Archiver();
            _gz2DlzEncoderFacade.GeometricTransformation = (int)G2_2D_LZ.Helpers.Constants.GeometricTransformation.VerticalMirror;

            G2_2D_LZ.Helpers.Constants.MinMatchSize = 5;

            _encoder           = new Gz2DlzEncoder(_gz2DlzEncoderFacade);
            _encoder.WorkImage = new byte[10, 12]
            {                                                    //0      1      2      3      4      5      6      7      8      9      10    11
                { 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },         //0
                { 0, 200, 0, 0, 0, 50, 100, 100, 0, 0, 50, 50 }, //1
                { 0, 250, 250, 250, 0, 0, 0, 0, 0, 0, 0, 0 },    //2
                { 0, 250, 250, 250, 0, 0, 0, 0, 0, 0, 0, 0 },    //3
                { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },          //4
                { 0, 0, 0, 0, 0, 0, 0, 0, 150, 0, 0, 0 },        //5
                { 0, 0, 0, 0, 0, 250, 250, 250, 150, 0, 0, 0 },  //6
                { 0, 0, 0, 0, 0, 250, 250, 250, 0, 0, 0, 0 },    //7
                { 0, 0, 0, 0, 0, 150, 150, 150, 0, 0, 0, 0 },    //8
                { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }           //9
            };
            _encoder.Encode();

            Assert.IsNotNull(_encoder.MatchLocation[6, 5]);
            Assert.AreEqual(1, _encoder.MatchLocation[6, 5].X);
            Assert.AreEqual(2, _encoder.MatchLocation[6, 5].Y);
        }
        public void ImageIsLoadedIntoMemory()
        {
            SetGz2DLzEncoderFacadeWithTestBmpABasedPredictorAndBmpReader();
            _encoder = new Gz2DlzEncoder(_gz2DlzEncoderFacade);

            byte[,] originalImage = _encoder.WorkImage;

            Assert.AreEqual(5, originalImage.GetLength(0));
            Assert.AreEqual(6, originalImage.GetLength(1));

            AssertEachValue(Constants.TestBmp, originalImage);
        }
        public void EncodeDoesntFindsTheExpectedBlockMatchIfThereAre2BlockAtTheSameOriginForMinMatchSize17()
        {
            _gz2DlzEncoderFacade.InputFilePath     = TwoPossibleMatchBlocksBmpPath;
            _gz2DlzEncoderFacade.AbstractPredictor = new ABasedPredictor();
            _gz2DlzEncoderFacade.ImageReader       = _bmpReader;
            _gz2DlzEncoderFacade.Archiver          = new Paq6V2Archiver();
            _encoder = new Gz2DlzEncoder(_gz2DlzEncoderFacade);

            _encoder.Encode();

            Assert.IsNull(_encoder.MatchLocation[1, 0]);
        }
        public void EncodeDoesntFindTheExpectedBlockMatchForMinMatchSize17()
        {
            _gz2DlzEncoderFacade.InputFilePath     = One3X4MatchBlockBmpPath;
            _gz2DlzEncoderFacade.AbstractPredictor = new ABasedPredictor();
            _gz2DlzEncoderFacade.ImageReader       = _bmpReader;
            _gz2DlzEncoderFacade.Archiver          = new Paq6V2Archiver();
            _encoder = new Gz2DlzEncoder(_gz2DlzEncoderFacade);

            _encoder.Encode();

            Assert.IsNull(_encoder.MatchLocation[6, 5]);
        }
示例#8
0
        private void button1_Click(object sender, System.EventArgs e)
        {
            IGz2DlzEncoderFacade _gz2DlzEncoderFacade = new Gz2DlzEncoderFacade();

            _gz2DlzEncoderFacade.InputFilePath     = inputFile;
            _gz2DlzEncoderFacade.AbstractPredictor = new ABasedPredictor();
            _gz2DlzEncoderFacade.ImageReader       = new BmpImageReader();
            _gz2DlzEncoderFacade.Archiver          = new Paq6V2Archiver();
            var _encoder = new Gz2DlzEncoder(_gz2DlzEncoderFacade);

            _encoder.Encode();
        }
        public void EncodesTheFirstRowIsMarkedAsEncoded()
        {
            SetGz2DLzEncoderFacadeWithTestBmpABasedPredictorAndBmpReader();
            _encoder = new Gz2DlzEncoder(_gz2DlzEncoderFacade);

            _encoder.Encode();

            var isEncodedPixel = _encoder.IsPixelEncoded;
            int y = 0;

            for (int x = 0; x < isEncodedPixel.GetLength(1); x++)
            {
                Assert.IsTrue(isEncodedPixel[y, x]);
            }
        }
        public void EncodeEncodesAllPixelsForAnImageWithAMatchingBlock()
        {
            SetGz2DLzEncoderFacadeWithTestBmpABasedPredictorAndBmpReader();
            _encoder = new Gz2DlzEncoder(_gz2DlzEncoderFacade);

            _encoder.Encode();

            var isEncodedPixel = _encoder.IsPixelEncoded;

            for (int y = 0; y < isEncodedPixel.GetLength(0); y++)
            {
                for (int x = 0; x < isEncodedPixel.GetLength(1); x++)
                {
                    Assert.IsTrue(isEncodedPixel[y, x]);
                }
            }
        }
        public void EncodesHasNoMatchDimensions()
        {
            SetGz2DLzEncoderFacadeWithTestBmpABasedPredictorAndBmpReader();
            _encoder = new Gz2DlzEncoder(_gz2DlzEncoderFacade);

            _encoder.Encode();

            var matchDimensions = _encoder.MatchDimension;

            for (int y = 0; y < matchDimensions.GetLength(0); y++)
            {
                for (int x = 0; x < matchDimensions.GetLength(1); x++)
                {
                    Assert.AreEqual(null, matchDimensions[y, x]);
                }
            }
        }
        public void EncodesHasNoResidualValues()
        {
            SetGz2DLzEncoderFacadeWithTestBmpABasedPredictorAndBmpReader();
            _encoder = new Gz2DlzEncoder(_gz2DlzEncoderFacade);

            _encoder.Encode();

            var residual = _encoder.Residual;

            for (int y = 0; y < residual.GetLength(0); y++)
            {
                for (int x = 0; x < residual.GetLength(1); x++)
                {
                    Assert.AreEqual(0, residual[y, x]);
                }
            }
        }
        public void EncodesHasNoMatchesFound()
        {
            SetGz2DLzEncoderFacadeWithTestBmpABasedPredictorAndBmpReader();
            _encoder = new Gz2DlzEncoder(_gz2DlzEncoderFacade);

            _encoder.Encode();

            var matchFlag = _encoder.IsMatchFound;

            for (int y = 0; y < matchFlag.GetLength(0); y++)
            {
                for (int x = 0; x < matchFlag.GetLength(1); x++)
                {
                    Assert.IsFalse(matchFlag[y, x]);
                }
            }
        }
示例#14
0
        private void LoadFolderBtn_Click(object sender, System.EventArgs e)
        {
            var dialogResult = folderBrowserDialog1.ShowDialog();

            if (dialogResult == DialogResult.OK)
            {
                var    folerPath        = folderBrowserDialog1.SelectedPath;
                var    allFilesInFolder = Directory.GetFiles(folerPath, "*.bmp");
                string content          = $@"Paramters: 
    SearchHeight : {G2_2D_LZ.Helpers.Constants.SearchHeight}
    SearchWidth : {G2_2D_LZ.Helpers.Constants.SearchWidth}
    Threshold : {G2_2D_LZ.Helpers.Constants.Threshold}
    MinMatchSize : {G2_2D_LZ.Helpers.Constants.MinMatchSize}
    MaxMse : {G2_2D_LZ.Helpers.Constants.MaxMse}
    NoMatchBlockWidth : {G2_2D_LZ.Helpers.Constants.NoMatchBlockWidth}
    NoMatchBlockHeight : {G2_2D_LZ.Helpers.Constants.NoMatchBlockHeight}
" + Environment.NewLine;
                content += "name | uncompressed size | compressed size | compression ratio | bits per pixel" + Environment.NewLine;

                foreach (var filePath in allFilesInFolder)
                {
                    string name             = Path.GetFileName(filePath);
                    var    uncompressedSize = new FileInfo(filePath).Length;

                    IGz2DlzEncoderFacade _gz2DlzEncoderFacade = new Gz2DlzEncoderFacade();
                    _gz2DlzEncoderFacade.InputFilePath     = filePath;
                    _gz2DlzEncoderFacade.AbstractPredictor = new ABasedPredictor();
                    _gz2DlzEncoderFacade.ImageReader       = new BmpImageReader();
                    _gz2DlzEncoderFacade.Archiver          = new Paq6V2Archiver();
                    var _encoder = new Gz2DlzEncoder(_gz2DlzEncoderFacade);
                    _encoder.Encode();
                    var archivePath    = _encoder.ArchivePath;
                    var compressedSize = new FileInfo(archivePath).Length;

                    content += $"{name} | {uncompressedSize} | {compressedSize} | " +
                               $" {uncompressedSize/(double)compressedSize} " +
                               $" | {8.0*(compressedSize / (double)(512 * 512))}  " +
                               $" {Environment.NewLine}";
                }

                using (var streamWriter = new StreamWriter(folerPath + "\\results.txt"))
                {
                    streamWriter.Write(content);
                }
            }
        }
示例#15
0
        public void EncodeAndDecodeWithCalicPredictorLenaBmpResultsTheSamePixels()
        {
            _gz2DlzEncoderFacade.InputFilePath     = _lenna256anBmpPath;
            _gz2DlzEncoderFacade.AbstractPredictor = new CalicPredictor();
            _gz2DlzEncoderFacade.ImageReader       = _bmpImageReader;
            _gz2DlzEncoderFacade.Archiver          = new Paq6V2Archiver();
            _encoder = new Gz2DlzEncoder(_gz2DlzEncoderFacade);

            var inputFilePath = _lenna256anBmpPath + G2_2D_LZ.Helpers.Constants.Folder + Constants.Paq6Extension;

            gz2DlzDecoderFacade = new Gz2DlzDecoderFacade();
            gz2DlzDecoderFacade.InputFilePath     = inputFilePath;
            gz2DlzDecoderFacade.AbstractPredictor = new CalicPredictor();
            gz2DlzDecoderFacade.Archiver          = new Paq6V2Archiver();
            _decoder = new Gz2DlzDecoder(gz2DlzDecoderFacade);

            _encoder.Encode();
            _decoder.Decode();

            var workImage = _decoder.WorkImage;

            CompareValueWithPixelFromBmp(_lenna256anBmpPath, workImage);
        }