remove some redundant variables and type params (#971)

SimonCropp · JimBobSquarePants · commit f115c160fc4b · 2019-08-13T09:33:39.000+10:00
* remove redundant variable init * redundant variables * remove redundant tileY variable * remove redundant sum variable * redundant mcu variable * redundant type params * Revert "remove redundant sum variable" This reverts commit 21de86c.
diff --git a/src/ImageSharp/Advanced/AotCompilerTools.cs b/src/ImageSharp/Advanced/AotCompilerTools.cs
@@ -133,7 +133,7 @@ private static void AotCompileDithering<TPixel>()
         {
             var test = new FloydSteinbergDiffuser();
             TPixel pixel = default;
-            test.Dither<TPixel>(new ImageFrame<TPixel>(Configuration.Default, 1, 1), pixel, pixel, 0, 0, 0, 0, 0, 0);
+            test.Dither(new ImageFrame<TPixel>(Configuration.Default, 1, 1), pixel, pixel, 0, 0, 0, 0, 0, 0);
         }
 
         /// <summary>
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/HuffmanScanDecoder.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/HuffmanScanDecoder.cs
@@ -209,7 +209,6 @@ private void ParseBaselineDataNonInterleaved()
             dcHuffmanTable.Configure();
             acHuffmanTable.Configure();
 
-            int mcu = 0;
             for (int j = 0; j < h; j++)
             {
                 Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(j);
@@ -228,9 +227,6 @@ ref Unsafe.Add(ref blockRef, i),
                         ref dcHuffmanTable,
                         ref acHuffmanTable);
 
-                    // Every data block is an MCU, so countdown the restart interval
-                    mcu++;
-
                     this.HandleRestart();
                 }
             }
@@ -379,7 +375,6 @@ private void ParseProgressiveDataNonInterleaved()
                 ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId];
                 dcHuffmanTable.Configure();
 
-                int mcu = 0;
                 for (int j = 0; j < h; j++)
                 {
                     Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(j);
@@ -397,8 +392,6 @@ private void ParseProgressiveDataNonInterleaved()
                             ref Unsafe.Add(ref blockRef, i),
                             ref dcHuffmanTable);
 
-                        // Every data block is an MCU, so countdown the restart interval
-                        mcu++;
                         this.HandleRestart();
                     }
                 }
@@ -408,7 +401,6 @@ ref Unsafe.Add(ref blockRef, i),
                 ref HuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId];
                 acHuffmanTable.Configure();
 
-                int mcu = 0;
                 for (int j = 0; j < h; j++)
                 {
                     Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(j);
@@ -425,8 +417,6 @@ ref Unsafe.Add(ref blockRef, i),
                             ref Unsafe.Add(ref blockRef, i),
                             ref acHuffmanTable);
 
-                        // Every data block is an MCU, so countdown the restart interval
-                        mcu++;
                         this.HandleRestart();
                     }
                 }
diff --git a/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Normalization/AdaptiveHistogramEqualizationProcessor{TPixel}.cs
@@ -77,25 +77,22 @@ protected override void OnFrameApply(ImageFrame<TPixel> source, Rectangle source
                     new ParallelOptions { MaxDegreeOfParallelism = configuration.MaxDegreeOfParallelism },
                     index =>
                         {
-                            int cdfX = 0;
-                            int tileX = 0;
-                            int tileY = 0;
                             int y = tileYStartPositions[index].y;
                             int cdfYY = tileYStartPositions[index].cdfY;
 
                             // It's unfortunate that we have to do this per iteration.
                             ref TPixel sourceBase = ref source.GetPixelReference(0, 0);
 
-                            cdfX = 0;
+                            int cdfX = 0;
                             for (int x = halfTileWidth; x < sourceWidth - halfTileWidth; x += tileWidth)
                             {
-                                tileY = 0;
+                                int tileY = 0;
                                 int yEnd = Math.Min(y + tileHeight, sourceHeight);
                                 int xEnd = Math.Min(x + tileWidth, sourceWidth);
                                 for (int dy = y; dy < yEnd; dy++)
                                 {
                                     int dyOffSet = dy * sourceWidth;
-                                    tileX = 0;
+                                    int tileX = 0;
                                     for (int dx = x; dx < xEnd; dx++)
                                     {
                                         ref TPixel pixel = ref Unsafe.Add(ref sourceBase, dyOffSet + dx);
@@ -221,7 +218,6 @@ private static void ProcessBorderColumn(
             int xEnd,
             int luminanceLevels)
         {
-            int halfTileWidth = tileWidth / 2;
             int halfTileHeight = tileHeight / 2;
 
             int cdfY = 0;
@@ -232,13 +228,11 @@ private static void ProcessBorderColumn(
                 for (int dy = y; dy < yLimit; dy++)
                 {
                     int dyOffSet = dy * sourceWidth;
-                    int tileX = halfTileWidth;
                     for (int dx = xStart; dx < xEnd; dx++)
                     {
                         ref TPixel pixel = ref Unsafe.Add(ref pixelBase, dyOffSet + dx);
                         float luminanceEqualized = InterpolateBetweenTwoTiles(pixel, cdfData, cdfX, cdfY, cdfX, cdfY + 1, tileY, tileHeight, luminanceLevels);
                         pixel.FromVector4(new Vector4(luminanceEqualized, luminanceEqualized, luminanceEqualized, pixel.ToVector4().W));
-                        tileX++;
                     }
 
                     tileY++;
@@ -277,7 +271,6 @@ private static void ProcessBorderRow(
             int cdfX = 0;
             for (int x = halfTileWidth; x < sourceWidth - halfTileWidth; x += tileWidth)
             {
-                int tileY = 0;
                 for (int dy = yStart; dy < yEnd; dy++)
                 {
                     int dyOffSet = dy * sourceWidth;
@@ -290,8 +283,6 @@ private static void ProcessBorderRow(
                         pixel.FromVector4(new Vector4(luminanceEqualized, luminanceEqualized, luminanceEqualized, pixel.ToVector4().W));
                         tileX++;
                     }
-
-                    tileY++;
                 }
 
                 cdfX++;
diff --git a/tests/ImageSharp.Tests/Formats/Gif/GifEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Gif/GifEncoderTests.cs
@@ -150,7 +150,7 @@ public void NonMutatingEncodePreservesPaletteCount()
                 outStream.Position = 0;
                 var clone = Image.Load<Rgba32>(outStream);
 
-                GifMetadata cloneMetaData = clone.Metadata.GetFormatMetadata<GifMetadata>(GifFormat.Instance);
+                GifMetadata cloneMetaData = clone.Metadata.GetFormatMetadata(GifFormat.Instance);
                 Assert.Equal(metaData.ColorTableMode, cloneMetaData.ColorTableMode);
 
                 // Gifiddle and Cyotek GifInfo say this image has 64 colors.
diff --git a/tests/ImageSharp.Tests/Image/ImageSaveTests.cs b/tests/ImageSharp.Tests/Image/ImageSaveTests.cs
@@ -52,7 +52,7 @@ public void SavePath()
             this.fileSystem.Setup(x => x.Create("path.png")).Returns(stream);
             this.Image.Save("path.png");
 
-            this.encoder.Verify(x => x.Encode<Rgba32>(this.Image, stream));
+            this.encoder.Verify(x => x.Encode(this.Image, stream));
         }
 
 
@@ -64,15 +64,15 @@ public void SavePathWithEncoder()
 
             this.Image.Save("path.jpg", this.encoderNotInFormat.Object);
 
-            this.encoderNotInFormat.Verify(x => x.Encode<Rgba32>(this.Image, stream));
+            this.encoderNotInFormat.Verify(x => x.Encode(this.Image, stream));
         }
 
         [Fact]
         public void ToBase64String()
         {
             string str = this.Image.ToBase64String(this.localImageFormat.Object);
 
-            this.encoder.Verify(x => x.Encode<Rgba32>(this.Image, It.IsAny<Stream>()));
+            this.encoder.Verify(x => x.Encode(this.Image, It.IsAny<Stream>()));
         }
 
         [Fact]
@@ -81,7 +81,7 @@ public void SaveStreamWithMime()
             Stream stream = new MemoryStream();
             this.Image.Save(stream, this.localImageFormat.Object);
 
-            this.encoder.Verify(x => x.Encode<Rgba32>(this.Image, stream));
+            this.encoder.Verify(x => x.Encode(this.Image, stream));
         }
 
         [Fact]
@@ -91,7 +91,7 @@ public void SaveStreamWithEncoder()
 
             this.Image.Save(stream, this.encoderNotInFormat.Object);
 
-            this.encoderNotInFormat.Verify(x => x.Encode<Rgba32>(this.Image, stream));
+            this.encoderNotInFormat.Verify(x => x.Encode(this.Image, stream));
         }
 
         public void Dispose()

Original file line number	Diff line number	Diff line change
`@@ -133,7 +133,7 @@ private static void AotCompileDithering<TPixel>()`
`133`	`133`	`{`
`134`	`134`	`var test = new FloydSteinbergDiffuser();`
`135`	`135`	`TPixel pixel = default;`
`136`		`- test.Dither<TPixel>(new ImageFrame<TPixel>(Configuration.Default, 1, 1), pixel, pixel, 0, 0, 0, 0, 0, 0);`
	`136`	`+ test.Dither(new ImageFrame<TPixel>(Configuration.Default, 1, 1), pixel, pixel, 0, 0, 0, 0, 0, 0);`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -209,7 +209,6 @@ private void ParseBaselineDataNonInterleaved()`
`209`	`209`	`dcHuffmanTable.Configure();`
`210`	`210`	`acHuffmanTable.Configure();`
`211`	`211`
`212`		`- int mcu = 0;`
`213`	`212`	`for (int j = 0; j < h; j++)`
`214`	`213`	`{`
`215`	`214`	`Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(j);`
`@@ -228,9 +227,6 @@ ref Unsafe.Add(ref blockRef, i),`
`228`	`227`	`ref dcHuffmanTable,`
`229`	`228`	`ref acHuffmanTable);`
`230`	`229`
`231`		`- // Every data block is an MCU, so countdown the restart interval`
`232`		`- mcu++;`
`233`		`-`
`234`	`230`	`this.HandleRestart();`
`235`	`231`	`}`
`236`	`232`	`}`
`@@ -379,7 +375,6 @@ private void ParseProgressiveDataNonInterleaved()`
`379`	`375`	`ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId];`
`380`	`376`	`dcHuffmanTable.Configure();`
`381`	`377`
`382`		`- int mcu = 0;`
`383`	`378`	`for (int j = 0; j < h; j++)`
`384`	`379`	`{`
`385`	`380`	`Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(j);`
`@@ -397,8 +392,6 @@ private void ParseProgressiveDataNonInterleaved()`
`397`	`392`	`ref Unsafe.Add(ref blockRef, i),`
`398`	`393`	`ref dcHuffmanTable);`
`399`	`394`
`400`		`- // Every data block is an MCU, so countdown the restart interval`
`401`		`- mcu++;`
`402`	`395`	`this.HandleRestart();`
`403`	`396`	`}`
`404`	`397`	`}`
`@@ -408,7 +401,6 @@ ref Unsafe.Add(ref blockRef, i),`
`408`	`401`	`ref HuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId];`
`409`	`402`	`acHuffmanTable.Configure();`
`410`	`403`
`411`		`- int mcu = 0;`
`412`	`404`	`for (int j = 0; j < h; j++)`
`413`	`405`	`{`
`414`	`406`	`Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(j);`
`@@ -425,8 +417,6 @@ ref Unsafe.Add(ref blockRef, i),`
`425`	`417`	`ref Unsafe.Add(ref blockRef, i),`
`426`	`418`	`ref acHuffmanTable);`
`427`	`419`
`428`		`- // Every data block is an MCU, so countdown the restart interval`
`429`		`- mcu++;`
`430`	`420`	`this.HandleRestart();`
`431`	`421`	`}`
`432`	`422`	`}`
Original file line number	Diff line number	Diff line change
`@@ -77,25 +77,22 @@ protected override void OnFrameApply(ImageFrame<TPixel> source, Rectangle source`
`77`	`77`	`new ParallelOptions { MaxDegreeOfParallelism = configuration.MaxDegreeOfParallelism },`
`78`	`78`	`index =>`
`79`	`79`	`{`
`80`		`- int cdfX = 0;`
`81`		`- int tileX = 0;`
`82`		`- int tileY = 0;`
`83`	`80`	`int y = tileYStartPositions[index].y;`
`84`	`81`	`int cdfYY = tileYStartPositions[index].cdfY;`
`85`	`82`
`86`	`83`	`// It's unfortunate that we have to do this per iteration.`
`87`	`84`	`ref TPixel sourceBase = ref source.GetPixelReference(0, 0);`
`88`	`85`
`89`		`- cdfX = 0;`
	`86`	`+ int cdfX = 0;`
`90`	`87`	`for (int x = halfTileWidth; x < sourceWidth - halfTileWidth; x += tileWidth)`
`91`	`88`	`{`
`92`		`- tileY = 0;`
	`89`	`+ int tileY = 0;`
`93`	`90`	`int yEnd = Math.Min(y + tileHeight, sourceHeight);`
`94`	`91`	`int xEnd = Math.Min(x + tileWidth, sourceWidth);`
`95`	`92`	`for (int dy = y; dy < yEnd; dy++)`
`96`	`93`	`{`
`97`	`94`	`int dyOffSet = dy * sourceWidth;`
`98`		`- tileX = 0;`
	`95`	`+ int tileX = 0;`
`99`	`96`	`for (int dx = x; dx < xEnd; dx++)`
`100`	`97`	`{`
`101`	`98`	`ref TPixel pixel = ref Unsafe.Add(ref sourceBase, dyOffSet + dx);`
`@@ -221,7 +218,6 @@ private static void ProcessBorderColumn(`
`221`	`218`	`int xEnd,`
`222`	`219`	`int luminanceLevels)`
`223`	`220`	`{`
`224`		`- int halfTileWidth = tileWidth / 2;`
`225`	`221`	`int halfTileHeight = tileHeight / 2;`
`226`	`222`
`227`	`223`	`int cdfY = 0;`
`@@ -232,13 +228,11 @@ private static void ProcessBorderColumn(`
`232`	`228`	`for (int dy = y; dy < yLimit; dy++)`
`233`	`229`	`{`
`234`	`230`	`int dyOffSet = dy * sourceWidth;`
`235`		`- int tileX = halfTileWidth;`
`236`	`231`	`for (int dx = xStart; dx < xEnd; dx++)`
`237`	`232`	`{`
`238`	`233`	`ref TPixel pixel = ref Unsafe.Add(ref pixelBase, dyOffSet + dx);`
`239`	`234`	`float luminanceEqualized = InterpolateBetweenTwoTiles(pixel, cdfData, cdfX, cdfY, cdfX, cdfY + 1, tileY, tileHeight, luminanceLevels);`
`240`	`235`	`pixel.FromVector4(new Vector4(luminanceEqualized, luminanceEqualized, luminanceEqualized, pixel.ToVector4().W));`
`241`		`- tileX++;`
`242`	`236`	`}`
`243`	`237`
`244`	`238`	`tileY++;`
`@@ -277,7 +271,6 @@ private static void ProcessBorderRow(`
`277`	`271`	`int cdfX = 0;`
`278`	`272`	`for (int x = halfTileWidth; x < sourceWidth - halfTileWidth; x += tileWidth)`
`279`	`273`	`{`
`280`		`- int tileY = 0;`
`281`	`274`	`for (int dy = yStart; dy < yEnd; dy++)`
`282`	`275`	`{`
`283`	`276`	`int dyOffSet = dy * sourceWidth;`
`@@ -290,8 +283,6 @@ private static void ProcessBorderRow(`
`290`	`283`	`pixel.FromVector4(new Vector4(luminanceEqualized, luminanceEqualized, luminanceEqualized, pixel.ToVector4().W));`
`291`	`284`	`tileX++;`
`292`	`285`	`}`
`293`		`-`
`294`		`- tileY++;`
`295`	`286`	`}`
`296`	`287`
`297`	`288`	`cdfX++;`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ public void SavePath()`
`52`	`52`	`this.fileSystem.Setup(x => x.Create("path.png")).Returns(stream);`
`53`	`53`	`this.Image.Save("path.png");`
`54`	`54`
`55`		`- this.encoder.Verify(x => x.Encode<Rgba32>(this.Image, stream));`
	`55`	`+ this.encoder.Verify(x => x.Encode(this.Image, stream));`
`56`	`56`	`}`
`57`	`57`
`58`	`58`
`@@ -64,15 +64,15 @@ public void SavePathWithEncoder()`
`64`	`64`
`65`	`65`	`this.Image.Save("path.jpg", this.encoderNotInFormat.Object);`
`66`	`66`
`67`		`- this.encoderNotInFormat.Verify(x => x.Encode<Rgba32>(this.Image, stream));`
	`67`	`+ this.encoderNotInFormat.Verify(x => x.Encode(this.Image, stream));`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`[Fact]`
`71`	`71`	`public void ToBase64String()`
`72`	`72`	`{`
`73`	`73`	`string str = this.Image.ToBase64String(this.localImageFormat.Object);`
`74`	`74`
`75`		`- this.encoder.Verify(x => x.Encode<Rgba32>(this.Image, It.IsAny<Stream>()));`
	`75`	`+ this.encoder.Verify(x => x.Encode(this.Image, It.IsAny<Stream>()));`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`[Fact]`
`@@ -81,7 +81,7 @@ public void SaveStreamWithMime()`
`81`	`81`	`Stream stream = new MemoryStream();`
`82`	`82`	`this.Image.Save(stream, this.localImageFormat.Object);`
`83`	`83`
`84`		`- this.encoder.Verify(x => x.Encode<Rgba32>(this.Image, stream));`
	`84`	`+ this.encoder.Verify(x => x.Encode(this.Image, stream));`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`[Fact]`
`@@ -91,7 +91,7 @@ public void SaveStreamWithEncoder()`
`91`	`91`
`92`	`92`	`this.Image.Save(stream, this.encoderNotInFormat.Object);`
`93`	`93`
`94`		`- this.encoderNotInFormat.Verify(x => x.Encode<Rgba32>(this.Image, stream));`
	`94`	`+ this.encoderNotInFormat.Verify(x => x.Encode(this.Image, stream));`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`public void Dispose()`