Esempio n. 1
0
        public void ReadBackPacketLengths()
        {
            // Test if the packet lengths we have
            // copied from the source tile-part, and written
            // into the destination tile-part, can be now
            // read back from the destination stream.
            // The source and destination packet lengths
            // should be equal
            _mem.Seek(0, SeekOrigin.Begin);
            var tpout = Jp2File.Open(_mem)
                        .OpenCodestream()
                        .OpenTilePart(0, 0);
            var lengthsOut = tpout.GetPacketLengths(
                0, tpout.Packets);
            var tpin      = _csin.OpenTilePart(0, 0);
            var lengthsIn = tpin.GetPacketLengths(
                0, tpin.Packets);
            bool seqEq = lengthsOut.SequenceEqual(lengthsIn);

            Assert.IsTrue(seqEq);
        }
Esempio n. 2
0
        public void OpenImage()
        {
            Jp2File jp2 = Jp2File.Open(_fs);

            Assert.IsNotNull(jp2);
            JP2Codestream cs = jp2.OpenCodestream();

            Assert.IsNotNull(cs);
            Assert.IsNull(cs.Parent);
            Assert.AreEqual <Size>(cs.ImageSize, Image.Default.ImageSize);
            Assert.AreEqual <Size>(cs.TileSize, Image.Default.ImageSize);
            Assert.AreEqual(cs.TileCount, new Size(1, 1));
            Assert.AreEqual(cs.Components, Image.Default.Components);
            Assert.AreEqual(cs.Progression, Image.Default.Progression);
            Assert.AreEqual(cs.ImageOffset, Point.Empty);
            Assert.AreEqual(cs.TileOffset, Point.Empty);
            Assert.AreEqual(cs.DecompositionLevels, Image.Default.Decompositions);
            Assert.AreEqual(cs.QualityLayers, 1);

            int tileparts = cs.OpenChildren().Count();

            Assert.AreEqual(1, tileparts);

            _fs.Seek(0, SeekOrigin.Begin);
            long socOffset = Find(_fs, (ushort)MarkerType.SOC);
            long sizOffset = Find(_fs, (ushort)MarkerType.SIZ);
            long sotOffset = Find(_fs, (ushort)MarkerType.SOT);
            long sodOffset = Find(_fs, (ushort)MarkerType.SOD);
            long eocOffset = Find(_fs, (ushort)MarkerType.EOC);

            Assert.AreEqual(socOffset, cs.Position);
            Assert.AreEqual(sizOffset, cs.Position + 2);
            Assert.AreEqual(sotOffset, cs.Position + cs.FirstChildOffset);
            long sodOffsetFromCs = cs.Position + cs.FirstChildOffset;

            sodOffsetFromCs += cs.OpenTilePart(0, 0).FirstChildOffset - 2;
            Assert.AreEqual(sodOffset, sodOffsetFromCs);
            Assert.AreEqual(eocOffset, cs.Position + cs.Length - 2);
        }
Esempio n. 3
0
        public void Initialize()
        {
            _fs   = File.OpenRead("test.jp2");
            _mem  = new MemoryStream();
            _csin = Jp2File.Open(_fs).OpenCodestream();
            var siz   = _csin.Markers[MarkerType.SIZ] as SizMarker;
            var cod   = _csin.Markers[MarkerType.COD] as CodMarker;
            var qcd   = _csin.Markers[MarkerType.QCD] as QcdMarker;
            var tpin  = _csin.OpenTilePart(0, 0);
            var csout = new JP2Codestream(new List <MarkerSegment>()
            {
                siz, cod, qcd
            }, 1);

            csout.Bind(_mem, 0);
            var tpout   = csout.CreateTilePart(0, true);
            var lengths = tpin.GetPacketLengths(0, tpin.Packets);

            tpout.AddPacketLengths(lengths);
            tpout.Flush();
            csout.Flush();
            _mem.Seek(0, SeekOrigin.Begin);
        }