# Resize Image

This Go code demonstrates the use of constants, basic image operations, and a function from the `image` package. Let's go through each part of the code:

```go
package main

import (
	"fmt"
	"image"
	"image/jpeg" // use "image/png" for png files
	"os"
)

func main() {
	// Change the file path to the location of the file
	filepath := "/Users/gnbhavithran/Non_python_programs/Go_lang/Test.jpg"
	file, err := os.Open(filepath)

  //Displays error if file not found or unaccessable
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer file.Close()

	// Decode the image file  
	img, _, err := image.Decode(file)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	width := img.Bounds().Dx()
	height := img.Bounds().Dy()

	// Create a new file to save the reshaped image 
	outputFile, err := os.Create("/Users/gnbhavithran/Non_python_programs/Go_lang/output1.jpg")
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer outputFile.Close()

	scale := 0.1  //Change the scale to the required size
	newWidth := int(float64(img.Bounds().Dx()) * scale)
	newHeight := int(float64(img.Bounds().Dy()) * scale)

	// Create a new RGBA image with the specified dimensions
	newImg := image.NewRGBA(image.Rect(0, 0, newWidth, newHeight))

	// Scale the original image to fit within the new dimensions
	for y := 0; y < newHeight; y++ {
		for x := 0; x < newWidth; x++ {
			// Map the coordinates from the new image to the original image
			origX := x * width / newWidth
			origY := y * height / newHeight

			// Set the color of the pixel in the new image to the color of the corresponding pixel in the original image
			newImg.Set(x, y, img.At(origX, origY))
		}
	}

  // Encoding the values into JPG 
	err = jpeg.Encode(outputFile, newImg, nil)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	fmt.Printf("Image resized to %d%% and saved successfully!", int(scale * 100))
}
```

When you run this Go program, it will output the values of the constants and the result of the mathematical operations to the console.

The output should be something like:

```
Image resized to 10% of Orginal size and saved successfully!
```

### Explanation:

1. `img.Bounds()`: Declares the boundary of the `Image`(img). `Dx` and `Dy` maximum value in X and Y axis.
2. `image.NewRGBA()`: An RGBA image is a standard image type where each pixel has four components: red, green, blue, and alpha (transparency) with boundaries given in "image.Rect()".
3. `image.Rect()`: representing the rectangle defined by the given coordinates.
4. `image.Decode()`: decode image data from an io.Reader into an image.Image object.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://ineelhere.gitbook.io/code-with-go/81-image-resize.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.