//水印
func waterMark(picBytes []byte) []byte {
// 打开水印图并解码
img, fileType, _ := image.Decode(bytes.NewBuffer(picBytes))
//读取水印图片
watermark, _ := png.Decode(bytes.NewBuffer(wm))
//原始图界限
origin_size := img.Bounds()
//创建新图层
canvas := image.NewNRGBA(origin_size)
//贴原始图
draw.Draw(canvas, origin_size, img, image.ZP, draw.Src)
//贴水印图
draw.Draw(canvas, watermark.Bounds().Add(image.Pt(origin_size.Dx()-watermark.Bounds().Dx(), origin_size.Dy()-watermark.Bounds().Dy()-4)), watermark, image.ZP, draw.Over)
//生成新图片
buff := bytes.NewBuffer([]byte{})
switch fileType {
case "jpeg":
jpeg.Encode(buff, canvas, &jpeg.Options{95})
default:
png.Encode(buff, canvas)
}
return buff.Bytes()
}
func main() {
var outFile *os.File
var err error
if outFile, err = os.Create("create.png"); err != nil {
println("Error", err)
return
}
defer outFile.Close()
rect := image.Rect(0, 0, 100, 100)
rgba := image.NewRGBA64(rect)
// #golangとか書きたいけど、とりあえず#だけ
for i := 0; i < 10; i++ {
rgba.Set(60, (10 + i), image.Black.At(0, 0))
rgba.Set(65, (10 + i), image.Black.At(0, 0))
rgba.Set((58 + i), 13, image.Black.At(0, 0))
rgba.Set((58 + i), 16, image.Black.At(0, 0))
}
outImage := rgba.SubImage(rect)
if err = png.Encode(outFile, outImage); err != nil {
println("Error", err)
return
}
}
func httpMakeImage() {
s := rand.NewSource(time.Now().UnixNano())
r := rand.New(s)
pixelcount := f_httpImageSize / 4
side := int(math.Sqrt(float64(pixelcount)))
log.Debug("Image served will be %v by %v", side, side)
m := image.NewRGBA(image.Rect(0, 0, side, side))
for i := 0; i < len(m.Pix); i++ {
m.Pix[i] = uint8(r.Int())
}
buf := new(bytes.Buffer)
if *f_httpGzip {
w := gzip.NewWriter(buf)
png.Encode(w, m)
w.Close()
} else {
png.Encode(buf, m)
}
httpImage = buf.Bytes()
}
// Save saves the texture as a PNG image.
func (a *TextureAtlas) Save(file string) (err error) {
fd, err := os.Create(file)
if err != nil {
return
}
defer fd.Close()
rect := image.Rect(0, 0, a.width, a.height)
switch a.depth {
case 1:
img := image.NewAlpha(rect)
copy(img.Pix, a.data)
err = png.Encode(fd, img)
case 3:
img := image.NewRGBA(rect)
copy(img.Pix, a.data)
err = png.Encode(fd, img)
case 4:
img := image.NewRGBA(rect)
copy(img.Pix, a.data)
err = png.Encode(fd, img)
}
return
}
func (ec *myEliteConsumer) OnElite(g *ga.IGenome) {
bits := (*g).GetBits()
newImage := createImageFromBitset(bits)
// Output elite
outputImageFile, _ := os.Create("elite.png")
png.Encode(outputImageFile, newImage)
outputImageFile.Close()
// Output elite with input image blended over the top
outputImageFileAlphaBlended, _ := os.Create("elite_with_original.png")
draw.DrawMask(newImage, newImage.Bounds(),
inputImage, image.ZP,
&image.Uniform{color.RGBA{0, 0, 0, 255 / 4}}, image.ZP,
draw.Over)
png.Encode(outputImageFileAlphaBlended, newImage)
outputImageFileAlphaBlended.Close()
ec.currentIter++
fitness := (*g).GetFitness()
fmt.Println(ec.currentIter, "\t", fitness, "\t", fitness-ec.previousFitness)
ec.previousFitness = fitness
time.Sleep(10 * time.Millisecond)
}
func main() {
w := 16
h := 16
img := image.NewRGBA(image.Rect(0, 0, w, h))
col := color.RGBA{255, 0, 0, 255}
for x := 0; x < w; x++ {
if x > 8 {
col = color.RGBA{0, 0, 255, 255}
}
for y := 0; y < h; y++ {
img.Set(x, y, col)
}
}
// 通过bytes创建writer
// http://stackoverflow.com/questions/23454940/getting-bytes-buffer-does-not-implement-io-writer-error-message
var b bytes.Buffer
foo := bufio.NewWriter(&b)
png.Encode(foo, img)
foo.Flush()
log.Println(b)
data := b.Bytes()
// 使用base64编码后，将str复制到浏览器中可以直接显示
str := base64.StdEncoding.EncodeToString(data)
str = "data:image/png;base64," + str
log.Println(str)
f, err := os.Create("test.png")
if err != nil {
panic(err)
}
defer f.Close()
png.Encode(f, img)
}
func TestGMProcess(t *testing.T) {
buffer := new(bytes.Buffer)
png.Encode(buffer, image.NewRGBA(image.Rect(0, 0, 200, 200)))
gm := NewGMProcessor()
params, _ := ParseParams("r_100x100,c_50x50,g_c,q_50")
img, err := gm.Process(params, "text.png", buffer)
assert.NoError(t, err)
assert.NotNil(t, img)
assert.True(t, img.Len() > 0)
buffer = new(bytes.Buffer)
png.Encode(buffer, image.NewRGBA(image.Rect(0, 0, 200, 200)))
params, _ = ParseParams("r_100x0,c_50x50,g_c,q_50")
img, err = gm.Process(params, "text.png", buffer)
assert.NoError(t, err)
assert.NotNil(t, img)
assert.True(t, img.Len() > 0)
buffer = new(bytes.Buffer)
png.Encode(buffer, image.NewRGBA(image.Rect(0, 0, 200, 200)))
params, _ = ParseParams("r_0x100,c_50x50,g_c,q_50")
img, err = gm.Process(params, "text.png", buffer)
assert.NoError(t, err)
assert.NotNil(t, img)
assert.True(t, img.Len() > 0)
}
func to_img(brot *[size][size]uint, max uint) {
gray := image.NewGray16(image.Rect(0, 0, size, size))
norm_gray := image.NewGray16(image.Rect(0, 0, size, size))
for x := 0; x < size; x++ {
for y := 0; y < size; y++ {
pix := brot[x][y]
norm := float64(brot[x][y]*4) / float64(max) * 65534
if norm > 65534 {
norm = 65534
}
if pix > 65534 {
pix = 65534
}
gray.SetGray16(
x, y,
color.Gray16{uint16(pix)})
norm_gray.SetGray16(
x, y,
color.Gray16{uint16(norm)})
}
}
w, _ := os.OpenFile("./brot.png", os.O_CREATE|os.O_WRONLY, 0666)
png.Encode(w, gray)
n, _ := os.OpenFile("./brot-norm.png", os.O_CREATE|os.O_WRONLY, 0666)
png.Encode(n, norm_gray)
}
func main() {
// quality := flag.Float64("quality", 0.7, "Quality of compression.")
benchmark := flag.Bool("benchmark", false, "Benchmark it.")
iterations := flag.Int("iterations", 100, "Iterations for benchmark")
flag.Parse()
if *cpuprofile != "" {
f, err := os.Create(*cpuprofile)
if err != nil {
log.Fatal(err)
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
filename := flag.Arg(0)
if *benchmark {
start := time.Now()
b := gutils.Screenshot().Bounds()
buf := make([]byte, b.Dx()*b.Dy()*4)
w := bytes.NewBuffer(buf)
for i := 0; i < *iterations; i++ {
m := gutils.Screenshot()
if filename != "" {
// f, err := os.Create(filename)
// if err != nil {
// fmt.Println("Benchmark failed:", err)
// return
// }
start := time.Now()
// jpeg.Encode(w, m, nil)
png.Encode(w, m)
fmt.Println(time.Since(start))
// f.Close()
}
}
delta := time.Now().Sub(start)
usedDisk := filename != ""
fmt.Printf(
"Result: iterations=%d, time=%s, fps=%d, disk=%t.\n", *iterations,
delta, *iterations*1e9/int(delta), usedDisk,
)
} else {
if filename == "" {
fmt.Println("Filename required.")
return
}
m := gutils.Screenshot()
f, err := os.Create(filename)
if err != nil {
fmt.Println("Benchmark failed:", err)
return
}
png.Encode(f, m)
f.Close()
}
}
func HandleImage(f func(img image.Image, ctx *ProxyCtx) image.Image) RespHandler {
return FuncRespHandler(func(resp *http.Response, ctx *ProxyCtx) *http.Response {
if !RespIsImage.HandleResp(resp, ctx) {
return resp
}
if resp.StatusCode != 200 {
// we might get 304 - not modified response without data
return resp
}
contentType := resp.Header.Get("Content-Type")
const kb = 1024
regret := regretable.NewRegretableReaderCloserSize(resp.Body, 16*kb)
resp.Body = regret
img, imgType, err := image.Decode(resp.Body)
if err != nil {
regret.Regret()
ctx.Warnf("%s: %s", ctx.Req.Method+" "+ctx.Req.URL.String()+" Image from "+ctx.Req.RequestURI+"content type"+
contentType+"cannot be decoded returning original image", err)
return resp
}
result := f(img, ctx)
buf := bytes.NewBuffer([]byte{})
switch contentType {
// No gif image encoder in go - convert to png
case "image/gif", "image/png":
if err := png.Encode(buf, result); err != nil {
ctx.Warnf("Cannot encode image, returning orig %v %v", ctx.Req.URL.String(), err)
return resp
}
resp.Header.Set("Content-Type", "image/png")
case "image/jpeg", "image/pjpeg":
if err := jpeg.Encode(buf, result, nil); err != nil {
ctx.Warnf("Cannot encode image, returning orig %v %v", ctx.Req.URL.String(), err)
return resp
}
case "application/octet-stream":
switch imgType {
case "jpeg":
if err := jpeg.Encode(buf, result, nil); err != nil {
ctx.Warnf("Cannot encode image as jpeg, returning orig %v %v", ctx.Req.URL.String(), err)
return resp
}
case "png", "gif":
if err := png.Encode(buf, result); err != nil {
ctx.Warnf("Cannot encode image as png, returning orig %v %v", ctx.Req.URL.String(), err)
return resp
}
}
default:
panic("unhandlable type" + contentType)
}
resp.Body = ioutil.NopCloser(buf)
return resp
})
}
func Julia(tType int, config Config) func(http.ResponseWriter, *http.Request, httprouter.Params) {
return func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
width, err := strconv.Atoi(ps.ByName("width"))
if err != nil {
width = 800
}
height, err := strconv.Atoi(ps.ByName("height"))
if err != nil {
height = 600
}
real, err := strconv.ParseFloat(ps.ByName("r"), 32)
if err != nil {
real = 1
}
imaginary, err := strconv.ParseFloat(ps.ByName("i"), 32)
if err != nil {
imaginary = 0.1
}
if height < 200 {
height = 200
} else if height > 1080 {
height = 1080
}
if width < 320 {
width = 320
} else if width > 1920 {
width = 1920
}
fileName := fmt.Sprintf("%s/juliasin-%d-%d-(%.16f)-(%.16f).png", config.CachePath, width, height, real, imaginary)
fileData, err := ioutil.ReadFile(fileName)
if err != nil || config.NoCache {
fractalImage := fractalgen.Julia(tType, width, height, complex(real, imaginary))
if !config.NoCache {
f, err := os.Create(fileName)
if err == nil {
png.Encode(f, fractalImage)
f.Close()
}
}
w.Header().Set("Content-Type", "image/png")
png.Encode(w, fractalImage)
} else {
w.Header().Set("Content-Type", "image/png")
w.Write(fileData)
}
}
}
func SaveImage(width, height int, frame *Frame, fn string) {
out, err := os.Create("./output/" + makeTimestamp() + ".png")
FailGracefully(err)
out2, err := os.Create("./output/" + fn + ".png")
FailGracefully(err)
fmt.Println("Saving As: ", makeTimestamp())
go FailGracefully(png.Encode(out, frame))
go FailGracefully(png.Encode(out2, frame))
}
func (p *comicPlugin) makeComic(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, script *comicgen.Script) {
p.Comics++
comic := comicgen.NewComicGen("arial", service.Name() != bruxism.DiscordServiceName)
image, err := comic.MakeComic(script)
if err != nil {
service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was an error creating the comic. %s", message.UserName(), err))
} else {
go func() {
if service.Name() == bruxism.DiscordServiceName {
discord := service.(*bruxism.Discord)
p, err := discord.UserChannelPermissions(message.UserID(), message.Channel())
if err == nil && p&discordgo.PermissionAttachFiles != 0 {
b := &bytes.Buffer{}
err = png.Encode(b, image)
if err != nil {
service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was a problem creating your comic.", message.UserName()))
return
}
if err := service.SendFile(message.Channel(), "comic.png", b); err == nil {
return
}
}
}
b := &bytes.Buffer{}
err = png.Encode(b, image)
if err != nil {
service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was a problem creating your comic.", message.UserName()))
return
}
url, err := bot.UploadToImgur(b, "comic.png")
if err != nil {
service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was a problem uploading the comic to imgur.", message.UserName()))
log.Println("Error uploading comic: ", err)
return
}
if service.Name() == bruxism.DiscordServiceName {
service.SendMessage(message.Channel(), fmt.Sprintf("Here's your comic <@%s>: %s", message.UserID(), url))
} else {
service.SendMessage(message.Channel(), fmt.Sprintf("Here's your comic %s: %s", message.UserName(), url))
}
runtime.GC()
}()
}
}
func processLayer(t *testing.T, f string, l *Layer) error {
if len(l.Layer) > 0 {
for i, ll := range l.Layer {
if err := processLayer(t, fmt.Sprintf("%s_%d", f, i), &ll); err != nil {
return err
}
}
}
if !l.HasImage() {
return nil
}
// write layer image per channel
for id, ch := range l.Channel {
if err := func() error {
o, err := os.Create(fmt.Sprintf("output/%s_Ch%d.png", f, id))
if err != nil {
return err
}
defer o.Close()
return png.Encode(o, ch.Picker)
}(); err != nil {
return err
}
}
for id, ch := range l.Channel {
verifyChannel(
t,
fmt.Sprintf("%s Ch:%d", f, id),
fmt.Sprintf("png/%s_Ch%d.png", f, id),
ch.Picker,
)
}
// write layer image
o, err := os.Create(fmt.Sprintf("output/%s.png", f))
if err != nil {
return err
}
defer o.Close()
err = png.Encode(o, l.Picker)
if err != nil {
return err
}
verifyImage(t, f, fmt.Sprintf("png/%s.png", f), l.Picker)
return nil
}
// UploadAvatar saves custom avatar for user.
// FIXME: split uploads to different subdirs in case we have massive users.
func (u *User) UploadAvatar(data []byte) error {
img, _, err := image.Decode(bytes.NewReader(data))
if err != nil {
return fmt.Errorf("Decode: %v", err)
}
m := resize.Resize(290, 290, img, resize.NearestNeighbor)
sess := x.NewSession()
defer sessionRelease(sess)
if err = sess.Begin(); err != nil {
return err
}
u.UseCustomAvatar = true
if err = updateUser(sess, u); err != nil {
return fmt.Errorf("updateUser: %v", err)
}
os.MkdirAll(setting.AvatarUploadPath, os.ModePerm)
fw, err := os.Create(u.CustomAvatarPath())
if err != nil {
return fmt.Errorf("Create: %v", err)
}
defer fw.Close()
if err = png.Encode(fw, m); err != nil {
return fmt.Errorf("Encode: %v", err)
}
return sess.Commit()
}
func addLogo(profilePtr *image.Image, logo string, context appengine.Context) []byte {
profileImage := *profilePtr
destImage := image.NewRGBA(profileImage.Bounds())
draw.Draw(destImage, destImage.Bounds(), profileImage, image.ZP, draw.Src)
if logoImages, ok := THELOGOIMAGES[logo]; ok {
randi := rand.Intn(len(logoImages))
logoImage := logoImages[randi]
offset := image.Pt(5, 5)
if strings.HasPrefix(logo, "NLD-") {
offset = image.Pt(0, 0)
}
start := profileImage.Bounds().Size()
start = start.Sub(offset)
start = start.Sub(logoImage.Bounds().Size())
bounds := image.Rectangle{start, start.Add(logoImage.Bounds().Size())}
draw.Draw(destImage, bounds, logoImage, image.ZP, draw.Over)
} else {
context.Errorf("Cannot load logoimage for %s", logo)
}
buffer := new(bytes.Buffer)
err := png.Encode(buffer, destImage)
check(err, context)
return buffer.Bytes()
}
func kartaPNGHandler(c *context, r *http.Request, w http.ResponseWriter) error {
if r.Method != "GET" {
return errors.New("no such handler")
}
seed := getInt(r, "s", 3, 0, math.MaxUint32)
width := getInt(r, "w", 512, 10, 5120)
height := getInt(r, "h", 512, 10, 5120)
count := getInt(r, "c", 2048, 3, 10000)
iterations := getInt(r, "i", 1, 0, 16)
// Seed the random number generator
rand.Seed(int64(seed))
// Create a new karta
k := karta.New(width, height, count, iterations)
if k.Generate() == nil {
w.Header().Add("Content-Type", "image/png")
err := png.Encode(w, k.Image)
if err != nil {
return err
}
c.logf("Served PNG count=%v width=%v height=%v iterations=%v seed=%v",
count, width, height, iterations, seed)
} else {
return errors.New("could not generate image")
}
return nil
}
func writeImageToFile(t *testing.T, img image.Image, dstFilename string, fileFmt string,
bmpOpts *EncoderOptions) {
var err error
file, err := os.Create(dstFilename)
if err != nil {
t.Logf("%s\n", err.Error())
t.FailNow()
return
}
defer file.Close()
if fileFmt == "png" {
err = png.Encode(file, img)
} else {
if bmpOpts != nil {
err = EncodeWithOptions(file, img, bmpOpts)
} else {
err = Encode(file, img)
}
}
if err != nil {
t.Logf("%s\n", err.Error())
t.FailNow()
return
}
}
func main() {
const maxX = 1024
const maxY = 800
const centerRe, centerIm float64 = -0.7435669, 0.1314023
const hd float64 = 0.0022878
const hv float64 = float64(maxY) / float64(maxX) * hd
const hdStepX = hd / maxX
const hdStepY = hv / maxY
const upperLeftRe = centerRe - (float64(maxX/2) * hdStepX)
const upperLeftIm = centerIm - (float64(maxY/2) * hdStepY)
f, err := os.Create("mandel.png")
if err != nil {
panic(err)
}
m := image.NewRGBA(image.Rect(0, 0, maxX, maxY))
b := m.Bounds()
for y := b.Min.Y; y < b.Max.Y; y++ {
for x := b.Min.X; x < b.Max.X; x++ {
dx := float64(x) * hdStepX
dy := float64(y) * hdStepY
iter := mandel.Iterate(upperLeftRe+dx, upperLeftIm+dy, 1024)
c := getColor(iter)
m.Set(x, maxY-y, c)
}
}
if err = png.Encode(f, m); err != nil {
panic(err)
}
}
func TestEncode(t *testing.T) {
img := prepareImg(t)
buf := &bytes.Buffer{}
if err := png.Encode(buf, img); err != nil {
t.Fatal(err)
}
imgGo, _, err := image.Decode(buf)
if err != nil {
t.Fatal(err)
}
assertEqual(t, img.Bounds(), imgGo.Bounds())
b, err := Encode(img, "png")
if err != nil {
t.Fatal(err)
}
imgMapnik, _, err := image.Decode(bytes.NewReader(b))
if err != nil {
t.Fatal(err)
}
assertImageEqual(t, img, imgMapnik)
assertImageEqual(t, imgGo, imgMapnik)
}
func createImage(iterations uint32, degree float64, factor float64) {
// Declare image size
width, height := 2048, 1024
// Create a new image
img := image.Rect(0, 0, width, height)
c := NewCanvas(img)
c.DrawGradient()
rand.Seed(time.Now().UTC().UnixNano())
for i := 0; i < 300; i++ {
x := float64(width) * rand.Float64()
y := float64(height) * rand.Float64()
color := color.RGBA{uint8(rand.Intn(255)),
uint8(rand.Intn(255)),
uint8(rand.Intn(255)),
255}
c.DrawSpiral(color, Coordinate{x, y}, iterations, degree, factor)
}
name := fmt.Sprintf("spiral_%d_%f_%f.png", iterations, degree, factor)
file, err := os.Create(name)
if err != nil {
log.Fatal(err)
}
defer file.Close()
png.Encode(file, c)
}
func main() {
if len(os.Args) != 2 {
fmt.Println("./ex08 [64|128] > result.png")
os.Exit(1)
}
const (
xmin, ymin, xmax, ymax = -2, -2, +2, +2
width, height = 1024, 1024
)
img := image.NewRGBA(image.Rect(0, 0, width, height))
for py := 0; py < height; py++ {
y := float64(py)/height*(ymax-ymin) + ymin
for px := 0; px < width; px++ {
x := float64(px)/width*(xmax-xmin) + xmin
z := complex(x, y)
// Image point (px, py) represents complex value z.
switch os.Args[1] {
case "64":
img.Set(px, py, mandelbrot64(complex64(z)))
case "128":
img.Set(px, py, mandelbrot128(z))
default:
fmt.Println("./ex08 [64|128]")
os.Exit(1)
}
}
}
png.Encode(os.Stdout, img) // NOTE: ignoring errors
}
func Write() {
err := png.Encode(PngFile, Pixels)
if err != nil {
fmt.Println(err)
}
// following line encodes pixel data only, not full png file
fi0, err := PngFile.Stat()
if err != nil {
fmt.Println(err)
}
d1 := make([]byte, fi0.Size())
_, err = PngFile.Seek(0, 0)
if err != nil {
fmt.Println(err)
}
_, err = PngFile.Read(d1)
if err != nil {
fmt.Println(err)
}
s0 := base64.StdEncoding.EncodeToString(d1)
s1 := "data:image/png;base64,"
s2 := fmt.Sprintf("%s%s", s1, s0)
d0 := Favio{DataUri: s2}
b0, err := json.Marshal(d0)
if err != nil {
fmt.Println(err)
}
_, err = JsonFile.Write(b0)
if err != nil {
fmt.Println(err)
}
}
func Example() {
// As usual in examples, this ignores all errors. Don't do this in your program.
// setup and find start point for centering
s := "Hello, World!"
size := image.Rect(0, 0, 120, 20)
dst := image.NewRGBA(size)
c := freetype.NewContext()
c.SetFont(font)
c.SetFontSize(14.0)
c.SetSrc(image.NewUniform(color.Black))
c.SetDst(dst)
start, _ := fontutil.CenterX(c, s, size) // CenterX calls c.SetClip(size)
// perform draw at start.X + y 16
c.DrawString(s, start.Add(freetype.Pt(0, 16)))
// write the image out to a file
// out, _ := os.Create("helloworld.png")
// defer out.Close()
// write image to hash for testing purposes
out := fnv.New64()
_ = png.Encode(out, dst)
fmt.Printf("Hash of compressed image: %x", out.Sum64())
// Output: Hash of compressed image: fa83a1b8d8abf5f2
}
func main() {
flag.Parse()
if *seed == 0 {
*seed = time.Now().UnixNano()
fmt.Println("seed", *seed)
}
interp := perlin.CosInterp
if *linInterp {
interp = perlin.LinearInterp
}
noise := perlin.Make(*persist, *scale, *noct, *seed, interp)
img := makeNoiseImg(*width, *height, noise)
f, err := os.Create(*outpath)
if err != nil {
panic(err)
}
defer f.Close()
if err := png.Encode(f, img); err != nil {
panic(err)
}
}
// encodedPNG encodes an image to PNG and returns
// the result as a byte slice.
func (m *Image) encodedPNG() []byte {
var buf bytes.Buffer
if err := png.Encode(&buf, m.Paletted); err != nil {
panic(err.Error())
}
return buf.Bytes()
}
func (converter *ImageConverter) convertToType(path string, newType string, channel chan int) {
file, _ := os.Open(path)
pathParts := strings.Split(path, "/")
filename := pathParts[len(pathParts)-1]
picture, format, _ := image.Decode(file)
rectangle := picture.Bounds()
modifier := converter.widthModifier(newType)
newWidth := uint(modifier * float32(rectangle.Dx()))
if newWidth < 1 {
newWidth = 1
}
newImage := resize.Resize(newWidth, 0, picture, resize.NearestNeighbor)
typeDirectory := strings.Join([]string{converter.Directory, "..", newType}, "/")
os.Mkdir(typeDirectory, 0700)
newFile, _ := os.Create(strings.Join([]string{typeDirectory, filename}, "/"))
switch format {
case "jpeg":
jpeg.Encode(newFile, newImage, nil)
case "png":
png.Encode(newFile, newImage)
}
file.Close()
newFile.Close()
channel <- 1
}
// GenerateRandomAvatar generates a random avatar for user.
func (u *User) GenerateRandomAvatar() error {
seed := u.Email
if len(seed) == 0 {
seed = u.Name
}
img, err := avatar.RandomImage([]byte(seed))
if err != nil {
return fmt.Errorf("RandomImage: %v", err)
}
if err = os.MkdirAll(filepath.Dir(u.CustomAvatarPath()), os.ModePerm); err != nil {
return fmt.Errorf("MkdirAll: %v", err)
}
fw, err := os.Create(u.CustomAvatarPath())
if err != nil {
return fmt.Errorf("Create: %v", err)
}
defer fw.Close()
if err = png.Encode(fw, img); err != nil {
return fmt.Errorf("Encode: %v", err)
}
log.Info("New random avatar created: %d", u.ID)
return nil
}
func main() {
f, err := os.Open("Pentagon.png")
if err != nil {
fmt.Println(err)
return
}
pent, err := png.Decode(f)
if err != nil {
fmt.Println(err)
return
}
if err = f.Close(); err != nil {
fmt.Println(err)
}
h := hough(pent, 460, 360)
if f, err = os.Create("hough.png"); err != nil {
fmt.Println(err)
return
}
if err = png.Encode(f, h); err != nil {
fmt.Println(err)
}
if cErr := f.Close(); cErr != nil && err == nil {
fmt.Println(err)
}
}
func (i TestImage) write(data image.Image) {
outfile, err := os.Create(string(i))
Expect(err).NotTo(HaveOccurred())
defer outfile.Close()
png.Encode(outfile, data)
}