Do rozdzielczosci jpg np. 736x1308 na Full HD 1920x1080

[Ricky2]

Zmiana rozmiaru na 800x600 oraz konwersja do odcieni szarości:

Bash

go run main.go -w 800 -h 600 -gray


Uruchomienie skompilowanego pliku .exe:

DOS
main.exe -w 1280 -h 720

Code: [Zaznacz cały] [Expand/Collapse] [Download] (LotharTeam.txt)

1. package main
2.  
3. import (
4.     "flag"
5.     "image"
6.     "image/color"
7.     "image/jpeg"
8.     "log"
9.     "math"
10.     "os"
11.     "path/filepath"
12. )
13.  
14. func bilinear(src image.Image, x, y float64) color.RGBA {
15.     x0 := int(math.Floor(x))
16.     y0 := int(math.Floor(y))
17.     x1 := x0 + 1
18.     y1 := y0 + 1
19.  
20.     c00 := src.At(x0, y0)
21.     c10 := src.At(x1, y0)
22.     c01 := src.At(x0, y1)
23.     c11 := src.At(x1, y1)
24.  
25.     dx := x - float64(x0)
26.     dy := y - float64(y0)
27.  
28.     r00, g00, b00, a00 := c00.RGBA()
29.     r10, g10, b10, a10 := c10.RGBA()
30.     r01, g01, b01, a01 := c01.RGBA()
31.     r11, g11, b11, a11 := c11.RGBA()
32.  
33.     r0 := float64(r00)*(1-dx) + float64(r10)*dx
34.     g0 := float64(g00)*(1-dx) + float64(g10)*dx
35.     b0 := float64(b00)*(1-dx) + float64(b10)*dx
36.     a0 := float64(a00)*(1-dx) + float64(a10)*dx
37.  
38.     r1 := float64(r01)*(1-dx) + float64(r11)*dx
39.     g1 := float64(g01)*(1-dx) + float64(g11)*dx
40.     b1 := float64(b01)*(1-dx) + float64(b11)*dx
41.     a1 := float64(a01)*(1-dx) + float64(a11)*dx
42.  
43.     r := r0*(1-dy) + r1*dy
44.     g := g0*(1-dy) + g1*dy
45.     b := b0*(1-dy) + b1*dy
46.     a := a0*(1-dy) + a1*dy
47.  
48.     // RGBA() zwraca 0–65535, więc dzielimy przez 257, żeby mieć 0–255
49.     return color.RGBA{
50.         uint8(r / 257.0),
51.         uint8(g / 257.0),
52.         uint8(b / 257.0),
53.         uint8(a / 257.0),
54.     }
55. }
56.  
57. func processImage(path string, outDir string, width, height int, grayscale bool) error {
58.     inFile, err := os.Open(path)
59.     if err != nil {
60.         return err
61.     }
62.     defer inFile.Close()
63.  
64.     srcImg, err := jpeg.Decode(inFile)
65.     if err != nil {
66.         return err
67.     }
68.  
69.     dst := image.NewRGBA(image.Rect(0, 0, width, height))
70.  
71.     srcW := srcImg.Bounds().Dx()
72.     srcH := srcImg.Bounds().Dy()
73.  
74.     scaleX := float64(srcW) / float64(width)
75.     scaleY := float64(srcH) / float64(height)
76.  
77.     for y := 0; y < height; y++ {
78.         sy := float64(y) * scaleY
79.         for x := 0; x < width; x++ {
80.             sx := float64(x) * scaleX
81.  
82.             c := bilinear(srcImg, sx, sy)
83.  
84.             if grayscale {
85.                 r := float64(c.R)
86.                 g := float64(c.G)
87.                 b := float64(c.B)
88.                 gray := uint8(0.299*r + 0.587*g + 0.114*b)
89.                 c = color.RGBA{gray, gray, gray, c.A}
90.             }
91.  
92.             dst.Set(x, y, c)
93.         }
94.     }
95.  
96.     outPath := filepath.Join(outDir, filepath.Base(path))
97.     outFile, err := os.Create(outPath)
98.     if err != nil {
99.         return err
100.     }
101.     defer outFile.Close()
102.  
103.     return jpeg.Encode(outFile, dst, &jpeg.Options{Quality: 95})
104. }
105.  
106. func main() {
107.     width := flag.Int("w", 1920, "docelowa szerokość (Full HD)")
108.     height := flag.Int("h", 1080, "docelowa wysokość (Full HD)")
109.     grayscale := flag.Bool("gray", false, "czy zastosować grayscale")
110.     flag.Parse()
111.  
112.     inDir := "jpg"// Stworzyc ikone "jpg" i tam skopiowac fotki.jpg // Jak zrobisz "bin" Tam skopiowac ikony "jpg" oraz "wynik"
113.     outDir := "wynik"// Sam stworzy ikone "wynik" Przy nacisnieciu "Go Run" // Przy nacisnieciu "Go BUILD" zrobisz "exe"
114.  
115.     os.MkdirAll(outDir, 0755)
116.  
117.     err := filepath.Walk(inDir, func(path string, info os.FileInfo, err error) error {
118.         if err != nil {
119.             return err
120.         }
121.  
122.         if !info.IsDir() && filepath.Ext(path) == ".jpg" {
123.             log.Println("Przetwarzam:", path)
124.             if err := processImage(path, outDir, *width, *height, *grayscale); err != nil {
125.                 log.Println("Błąd:", err)
126.             }
127.         }
128.         return nil
129.     })
130.  
131.     if err != nil {
132.         log.Fatal(err)
133.     }
134.  
135.     log.Println("Zakończono obróbkę zdjęć.")
136. }
137.  

[SunRiver]

Można by go na gforutines zrównoleglić , ale i tak dobra robota