Go - Flipping an Image Upside Down

Problem: You want to flip an image upside down.

Solution: Convert an image to a grid of pixels. Swap the positions of the top and bottom pairs of pixels and move down to swap the next pair until all the pixel positions are swapped. Convert the grid of pixels back into a flipped image.

The Image implementations (for example, image.NRGBA ) have a slice of bytes that represent pixels in the image. That’s not the most intuitive way to represent a raster image. What’s more common is a grid of pixels (because a raster image is literally a grid of pixels), so that’s the first thing you want to do — convert an image.NRGBA to a grid of pixels.

In the image package , a pixel is represented by the type color.Color so you’re going to create a 2D slice of color.Color pixels. You will extend the load function from before to do this so you can return the grid:

func   load ( filePath   string )   ( grid   [][] color . Color )   { 
      //  open  the  file  and  decode  the  contents  into  an  image 
      file ,   err   :=   os . Open ( filePath ) 
      if   err   !=   nil   { 
          log . Println ( "Cannot  read  file:" ,   err ) 
      } 
      defer   file . Close () 
      img ,   _ ,   err   :=   image . Decode ( file ) 
      if   err   !=   nil   { 
          log . Println ( "Cannot  decode  file:" ,   err ) 
      } 
      //  create  and  return  a  grid  of  pixels 
      size   :=   img . Bounds (). Size () 
      for   i   :=   0 ;   i   <   size . X ;   i ++   { 
          var   y   [] color . Color 
          for   j   :=   0 ;   j   <   size . Y ;   j ++   { 
              y   =   append ( y ,   img . At ( i ,   j )) 
          } 
          grid   =   append ( grid ,   y ) 
      } 
      return 
}

To convert the image into a grid, you need to find out the size of the image. Use the Size method on the Rect struct that is returned from calling the Bounds method on the image. This returns a Point , which gives you the X and Y width and length of the image. Iterate the width and length, and at each pixel position, use the At method to get the pixel color.Color . This will give you a grid of color.Color pixels.

You will also need to extend the save function to let you save the grid of pixels back into a file:

func   save ( filePath   string ,   grid   [][] color . Color )   { 
      //  create  an  image  and  set  the  pixels  using  the  grid 
      xlen ,   ylen   :=   len ( grid ),   len ( grid [ 0 ]) 
      rect   :=   image . Rect ( 0 ,   0 ,   xlen ,   ylen ) 
      img   :=   image . NewNRGBA ( rect ) 
      for   x   :=   0 ;   x   <   xlen ;   x ++   { 
          for   y   :=   0 ;   y   <   ylen ;   y ++   { 
              img . Set ( x ,   y ,   grid [ x ][ y ]) 
          } 
      } 
      //  create  a  file  and  encode  the  image  into  it 
      file ,   err   :=   os . Create ( filePath ) 
      if   err   !=   nil   { 
          log . Println ( "Cannot  create  file:" ,   err ) 
      } 
      defer   file . Close () 
      png . Encode ( file ,   img . SubImage ( img . Rect )) 
}

First, you need to create an image. Using the width and length of the 2D slice, create a Rect to represent the size of the image. Create a new image using the image.NewNRGBA function, passing it the Rect . Then iterate through the grid and at every position, set the color.Color pixel from the grid into the new image.

Finally, take the image and encode it into a file.

Now that you can load an image file into a grid of pixels and save it back into an image file, look at the algorithm you want to use to flip the image upside down:

func   flip ( grid   [][] color . Color )   { 
      for   x   :=   0 ;   x   <   len ( grid );   x ++   { 
          col   :=   grid [ x ] 
          for   y   :=   0 ;   y   <   len ( col ) / 2 ;   y ++   { 
              z   :=   len ( col )   -   y   -   1 
              col [ y ],   col [ z ]   =   col [ z ],   col [ y ] 
          } 
      } 
}

It’s relatively simple to flip the image with a grid of pixels. You simply iterate through each column of the grid and swap the top and bottom pixels. Here’s how you can use this algorithm to flip the image:

func   main ()   { 
      grid   :=   load ( "monalisa.png" ) 
      flip ( grid ) 
      save ( "flipped.png" ,   grid ) 
}