|
6
|
1 /* Image Manipulator - ver 0.3 ( Last Change: 2016-10-27 Thu 20:38:25.) */
|
|
0
|
2 package main
|
|
|
3
|
|
|
4 import(
|
|
|
5 "errors"
|
|
|
6 "flag"
|
|
|
7 "fmt"
|
|
|
8 "image"
|
|
|
9 "image/jpeg"
|
|
|
10 "image/png"
|
|
|
11 "io"
|
|
|
12 "os"
|
|
|
13 "strings"
|
|
|
14 "strconv"
|
|
|
15 )
|
|
|
16
|
|
|
17 func main() {
|
|
6
|
18 ver := "0.3"
|
|
0
|
19
|
|
|
20 // arguments
|
|
|
21 kind := flag.String( "t", "", "file type : jpeg / png" )
|
|
|
22 resize := flag.String( "s", "", "new size : 600x800 / 320x0 / ..." )
|
|
|
23 crop := flag.String( "c", "", "crop size : 300x200+10+35" )
|
|
|
24 angle := flag.Uint( "r", 0, "rotate : 90 / 180 / 270" )
|
|
6
|
25 dump := flag.Bool( "d", false, "dump RGBA : [no argument]")
|
|
0
|
26
|
|
|
27 flag.Parse()
|
|
|
28 if flag.NFlag() == 0 {
|
|
|
29 fmt.Fprintf( os.Stderr, "\n=== Image-Manipulator - version %s ===", ver )
|
|
|
30 fmt.Fprintf( os.Stderr, "\n$ imgmanip [option parameter] < infile > outfile\n" )
|
|
|
31 flag.PrintDefaults()
|
|
|
32 os.Exit( 1 )
|
|
|
33 }
|
|
|
34
|
|
6
|
35 switch {
|
|
|
36 // convert
|
|
|
37 case *kind != "" :
|
|
|
38 err := Convert( os.Stdin, os.Stdout, *kind ); if err != nil {
|
|
|
39 fmt.Fprintf( os.Stderr, "%s: %v\n", *kind, err )
|
|
|
40 os.Exit( 1 )
|
|
|
41 }
|
|
0
|
42
|
|
6
|
43 // resize
|
|
|
44 case *resize != "" :
|
|
|
45 err := Resize( os.Stdin, os.Stdout, *resize ); if err != nil {
|
|
|
46 fmt.Fprintf( os.Stderr, "resize: %v\n", err )
|
|
|
47 os.Exit( 1 )
|
|
|
48 }
|
|
0
|
49
|
|
6
|
50 // crop
|
|
|
51 case *crop != "" :
|
|
|
52 err := Crop( os.Stdin, os.Stdout, *crop ); if err != nil {
|
|
|
53 fmt.Fprintf( os.Stderr, "crop: %v\n", err )
|
|
|
54 os.Exit( 1 )
|
|
|
55 }
|
|
0
|
56
|
|
6
|
57 // rotate
|
|
|
58 case *angle != 0 :
|
|
|
59 err := Rotate( os.Stdin, os.Stdout, *angle ); if err != nil {
|
|
|
60 fmt.Fprintf( os.Stderr, "rotate: %v\n", err )
|
|
|
61 os.Exit( 1 )
|
|
|
62 }
|
|
|
63
|
|
|
64 // dump
|
|
|
65 case *dump :
|
|
|
66 err := Dump( os.Stdin ); if err != nil {
|
|
|
67 fmt.Fprintf( os.Stderr, "dump: %v\n", err )
|
|
|
68 os.Exit( 1 )
|
|
|
69 }
|
|
|
70
|
|
|
71
|
|
|
72 }
|
|
0
|
73 }
|
|
|
74
|
|
|
75 func Convert( in io.Reader, out io.Writer, kind string ) error {
|
|
|
76
|
|
|
77 img, _, err := image.Decode( in ); if err != nil {
|
|
|
78 return err
|
|
|
79 }
|
|
|
80
|
|
|
81 switch kind {
|
|
|
82 case "jpeg":
|
|
|
83 return jpeg.Encode( out, img, &jpeg.Options{ Quality: 100 } )
|
|
|
84 case "png":
|
|
|
85 return png.Encode( out, img )
|
|
|
86 }
|
|
|
87
|
|
|
88 return errors.New( "image-type is not supported")
|
|
|
89 }
|
|
|
90
|
|
|
91 func Resize( in io.Reader, out io.Writer, size string ) error {
|
|
|
92
|
|
|
93 img, kind, err := image.Decode( in ); if err != nil {
|
|
|
94 return err
|
|
|
95 }
|
|
|
96 srcW := img.Bounds().Max.X
|
|
|
97 srcH := img.Bounds().Max.Y
|
|
|
98
|
|
|
99 wh := strings.Split( size, "x" )
|
|
|
100 w, err := strconv.Atoi( wh[0] ); if err != nil || w < 0 {
|
|
|
101 return errors.New( "invalid width" )
|
|
|
102 }
|
|
|
103 h, err := strconv.Atoi( wh[1] ); if err != nil || h < 0 {
|
|
|
104 return errors.New( "invalid height" )
|
|
|
105 }
|
|
|
106 if w == 0 && h == 0 {
|
|
|
107 return errors.New( "invalid size" )
|
|
|
108 }
|
|
|
109 if w == 0 {
|
|
|
110 w = h * srcW / srcH
|
|
|
111 }
|
|
|
112 if h == 0 {
|
|
|
113 h = w * srcH / srcW
|
|
|
114 }
|
|
|
115
|
|
|
116 dst := image.NewNRGBA( image.Rect( 0, 0, w, h ) )
|
|
|
117 for x := 0; x < w; x++ {
|
|
|
118 for y := 0; y < h; y++ {
|
|
|
119 dst.Set( x, y, img.At( x * srcW / w, y * srcH / h ) )
|
|
|
120 }
|
|
|
121 }
|
|
|
122
|
|
|
123 switch kind {
|
|
|
124 case "jpeg":
|
|
|
125 return jpeg.Encode( out, dst, &jpeg.Options{ Quality: 100 } )
|
|
|
126 case "png":
|
|
|
127 return png.Encode( out, dst )
|
|
|
128 }
|
|
|
129
|
|
|
130 return errors.New( "image-type is not supported")
|
|
|
131 }
|
|
|
132
|
|
|
133 func Crop( in io.Reader, out io.Writer, geo string ) error {
|
|
|
134
|
|
|
135 img, kind, err := image.Decode( in ); if err != nil {
|
|
|
136 return err
|
|
|
137 }
|
|
|
138 srcW := img.Bounds().Max.X
|
|
|
139 srcH := img.Bounds().Max.Y
|
|
|
140
|
|
|
141 buf := strings.Split( geo, "x" )
|
|
|
142 w, err := strconv.Atoi( buf[0] ); if err != nil || w < 0 || w > srcW {
|
|
|
143 return errors.New( "invalid width" )
|
|
|
144 }
|
|
|
145 buf = strings.Split( buf[1], "+" )
|
|
|
146 h, err := strconv.Atoi( buf[0] ); if err != nil || h < 0 || h > srcH {
|
|
|
147 return errors.New( "invalid height" )
|
|
|
148 }
|
|
|
149 x0, err := strconv.Atoi( buf[1] ); if err != nil || x0 < 0 {
|
|
|
150 return errors.New( "invalid x" )
|
|
|
151 }
|
|
|
152 y0, err := strconv.Atoi( buf[2] ); if err != nil || y0 < 0 {
|
|
|
153 return errors.New( "invalid y" )
|
|
|
154 }
|
|
|
155
|
|
|
156 var dst *image.NRGBA
|
|
|
157
|
|
|
158 dst = image.NewNRGBA( image.Rect( 0, 0, w, h ) )
|
|
|
159 for x := 0; x < x0 + w; x++ {
|
|
|
160 for y := 0; y < y0 + h; y++ {
|
|
|
161 dst.Set( x, y, img.At( x0 + x, y0 + y ) )
|
|
|
162 }
|
|
|
163 }
|
|
|
164
|
|
|
165 switch kind {
|
|
|
166 case "jpeg":
|
|
|
167 return jpeg.Encode( out, dst, &jpeg.Options{ Quality: 100 } )
|
|
|
168 case "png":
|
|
|
169 return png.Encode( out, dst )
|
|
|
170 }
|
|
|
171
|
|
|
172 return errors.New( "image-type is not supported")
|
|
|
173 }
|
|
|
174
|
|
|
175 func Rotate( in io.Reader, out io.Writer, angle uint ) error {
|
|
|
176
|
|
|
177 img, kind, err := image.Decode( in ); if err != nil {
|
|
|
178 return err
|
|
|
179 }
|
|
|
180 srcW := img.Bounds().Max.X
|
|
|
181 srcH := img.Bounds().Max.Y
|
|
|
182
|
|
|
183 var dst *image.NRGBA
|
|
|
184 switch angle {
|
|
|
185 case 90:
|
|
|
186 dst = image.NewNRGBA( image.Rect( 0, 0, srcH, srcW ) )
|
|
|
187 for x := 0; x < srcH; x++ {
|
|
|
188 for y := 0; y < srcW; y++ {
|
|
|
189 dst.Set( x, y, img.At( y, srcH - x ) )
|
|
|
190 }
|
|
|
191 }
|
|
|
192 case 180:
|
|
|
193 dst = image.NewNRGBA( image.Rect( 0, 0, srcW, srcH ) )
|
|
|
194 for x := 0; x < srcW; x++ {
|
|
|
195 for y := 0; y < srcH; y++ {
|
|
|
196 dst.Set( x, y, img.At( srcW - x, srcH - y ) )
|
|
|
197 }
|
|
|
198 }
|
|
|
199 case 270:
|
|
|
200 dst = image.NewNRGBA( image.Rect( 0, 0, srcH, srcW ) )
|
|
|
201 for x := 0; x < srcH; x++ {
|
|
|
202 for y := 0; y < srcW; y++ {
|
|
|
203 dst.Set( x, y, img.At( y, x ) )
|
|
|
204 }
|
|
|
205 }
|
|
|
206 default:
|
|
|
207 return errors.New( "bad angle" )
|
|
|
208 }
|
|
|
209
|
|
|
210 switch kind {
|
|
|
211 case "jpeg":
|
|
|
212 return jpeg.Encode( out, dst, &jpeg.Options{ Quality: 100 } )
|
|
|
213 case "png":
|
|
|
214 return png.Encode( out, dst )
|
|
|
215 }
|
|
|
216
|
|
|
217 return errors.New( "image-type is not supported")
|
|
|
218 }
|
|
|
219
|
|
6
|
220 func Dump( in io.Reader ) error {
|
|
|
221 img, _, err := image.Decode( in ); if err != nil {
|
|
|
222 return err
|
|
|
223 }
|
|
|
224
|
|
|
225 bounds := img.Bounds()
|
|
|
226 for y:= bounds.Min.Y; y < bounds.Max.Y; y++ {
|
|
|
227 for x:= bounds.Min.X; x < bounds.Max.X; x++ {
|
|
|
228 r, g, b, a := img.At( x, y ).RGBA()
|
|
|
229 fmt.Printf( "(%d,%d) = %d,%d,%d,%d\n", x, y, r>>8, g>>8, b>>8, a>>8 )
|
|
|
230 }
|
|
|
231 }
|
|
|
232 return nil
|
|
|
233 }
|
|
|
234
|
