Example #1
0
        public void TestSRational()
        {
            var defaultSRational = new TiffSRational();

            Assert.Equal(0, defaultSRational.Numerator);
            Assert.Equal(0, defaultSRational.Denominator);
            Assert.Equal(0 / 0f, defaultSRational.ToSingle());
            Assert.Equal(0 / 0d, defaultSRational.ToDouble());

            var srational1 = new TiffSRational(1, -2);

            Assert.Equal(1, srational1.Numerator);
            Assert.Equal(-2, srational1.Denominator);
            Assert.False(srational1.Equals(defaultSRational));
            Assert.False(defaultSRational.Equals(srational1));
            Assert.False(srational1 == defaultSRational);
            Assert.False(defaultSRational == srational1);
            Assert.True(srational1 != defaultSRational);
            Assert.True(defaultSRational != srational1);
            Assert.False(srational1.GetHashCode() == defaultSRational.GetHashCode());
            Assert.Equal(-1 / 2f, srational1.ToSingle());
            Assert.Equal(-1 / 2d, srational1.ToDouble());

            var srational2 = new TiffSRational(1, -2);

            Assert.True(srational1.Equals(srational2));
            Assert.True(srational2.Equals(srational1));
            Assert.True(srational1 == srational2);
            Assert.True(srational2 == srational1);
            Assert.False(srational1 != srational2);
            Assert.False(srational2 != srational1);
            Assert.True(srational1.GetHashCode() == srational2.GetHashCode());
        }
        /// <summary>
        /// Returns the TIFF tag information.
        /// </summary>
        /// <param name="tagId">The tag identifier.</param>
        /// <param name="tagValue">The tag value.</param>
        private bool GetTiffTagInfo(out int tagId, out object tagValue)
        {
            tagId    = 0;
            tagValue = (int)0;

            using (AddTiffTagForm dlg = new AddTiffTagForm())
            {
                if (dlg.ShowDialog() == DialogResult.OK)
                {
                    tagId = dlg.TagId;


                    // get the tag data value

                    switch (dlg.TagDataType)
                    {
                    case TiffTagDataType.Ascii:
                        tagValue = dlg.StringValue;
                        break;

                    case TiffTagDataType.Short:
                        tagValue = (ushort)dlg.IntegerValue;
                        break;

                    case TiffTagDataType.SShort:
                        tagValue = (short)dlg.IntegerValue;
                        break;

                    case TiffTagDataType.Long:
                        tagValue = (uint)dlg.IntegerValue;
                        break;

                    case TiffTagDataType.SLong:
                        tagValue = (int)dlg.IntegerValue;
                        break;

                    case TiffTagDataType.Float:
                        tagValue = (float)dlg.DoubleValue;
                        break;

                    case TiffTagDataType.Double:
                        tagValue = dlg.DoubleValue;
                        break;

                    case TiffTagDataType.Rational:
                        // create long rational value
                        tagValue = new TiffRational((uint)dlg.NumeratorValue, (uint)dlg.DenominatorValue);
                        break;

                    case TiffTagDataType.SRational:
                        // create short long rational value
                        tagValue = new TiffSRational((int)dlg.NumeratorValue, (uint)dlg.DenominatorValue);
                        break;
                    }
                    return(true);
                }
            }
            return(false);
        }
Example #3
0
        public async Task TestSRationalCompatibility(int length, bool bigTiff)
        {
            TiffSRational[] refData = new TiffSRational[length];
            new Random(42).NextBytes(MemoryMarshal.AsBytes(refData.AsSpan()));

            using Stream stream = await GenerateTiffAsync(bigTiff, async ifd =>
            {
                await ifd.WriteTagAsync((TiffTag) 0x1234, TiffValueCollection.UnsafeWrap(refData));
            });

            await using (TiffFileReader reader = await TiffFileReader.OpenAsync(stream, leaveOpen: true))
            {
                TiffImageFileDirectory ifd = await reader.ReadImageFileDirectoryAsync();

                TiffFieldReader fieldReader = await reader.CreateFieldReaderAsync();

                TiffImageFileDirectoryEntry entry = ifd.FindEntry((TiffTag)0x1234);
                Assert.Equal((TiffTag)0x1234, entry.Tag);

                // Byte
                await TestInvalidConversionAsync <byte>(fieldReader, entry, nameof(fieldReader.ReadByteFieldAsync), refData.Length);

                // SSbyte
                await TestInvalidConversionAsync <sbyte>(fieldReader, entry, nameof(fieldReader.ReadSByteFieldAsync), refData.Length);

                // Short
                await TestInvalidConversionAsync <ushort>(fieldReader, entry, nameof(fieldReader.ReadShortFieldAsync), refData.Length);

                // SShort
                await TestInvalidConversionAsync <short>(fieldReader, entry, nameof(fieldReader.ReadSShortFieldAsync), refData.Length);

                // Long
                await TestInvalidConversionAsync <uint>(fieldReader, entry, nameof(fieldReader.ReadLongFieldAsync), refData.Length);

                // SLong
                await TestInvalidConversionAsync <int>(fieldReader, entry, nameof(fieldReader.ReadSLongFieldAsync), refData.Length);

                // Float
                await TestInvalidConversionAsync <float>(fieldReader, entry, nameof(fieldReader.ReadFloatFieldAsync), refData.Length);

                // Double
                await TestInvalidConversionAsync <double>(fieldReader, entry, nameof(fieldReader.ReadDoubleFieldAsync), refData.Length);

                // Rational
                await TestInvalidConversionAsync <TiffRational>(fieldReader, entry, nameof(fieldReader.ReadRationalFieldAsync), refData.Length);

                // SRational
                await TestValidConversionAsync(fieldReader, entry, nameof(fieldReader.ReadSRationalFieldAsync), refData);
            }
        }