public void TestRational()
        {
            var defaultRational = new TiffRational();

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

            var rational1 = new TiffRational(1, 2);

            Assert.Equal((uint)1, rational1.Numerator);
            Assert.Equal((uint)2, rational1.Denominator);
            Assert.False(rational1.Equals(defaultRational));
            Assert.False(defaultRational.Equals(rational1));
            Assert.False(rational1 == defaultRational);
            Assert.False(defaultRational == rational1);
            Assert.True(rational1 != defaultRational);
            Assert.True(defaultRational != rational1);
            Assert.False(rational1.GetHashCode() == defaultRational.GetHashCode());
            Assert.Equal(1 / 2f, rational1.ToSingle());
            Assert.Equal(1 / 2d, rational1.ToDouble());

            var rational2 = new TiffRational(1, 2);

            Assert.True(rational1.Equals(rational2));
            Assert.True(rational2.Equals(rational1));
            Assert.True(rational1 == rational2);
            Assert.True(rational2 == rational1);
            Assert.False(rational1 != rational2);
            Assert.False(rational2 != rational1);
            Assert.True(rational1.GetHashCode() == rational2.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);
        }
Exemple #3
0
        public async Task TestRationalCompatibility(int length, bool bigTiff)
        {
            TiffRational[] refData = new TiffRational[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 TestValidConversionAsync(fieldReader, entry, nameof(fieldReader.ReadRationalFieldAsync), refData);

                // SRational
                await TestInvalidConversionAsync <TiffSRational>(fieldReader, entry, nameof(fieldReader.ReadSRationalFieldAsync), refData.Length);
            }
        }