// Sets skin.Processed to an isometric render of the head from a top-left angle (showing 3 sides). func (skin *mcSkin) GetCube(width int) error { // Crop out the top of the head topFlat := imaging.Crop(skin.Image, image.Rect(8, 0, 16, 8)) // Resize appropriately, so that it fills the `width` when rotated 45 def. topFlat = imaging.Resize(topFlat, int(float64(width)*math.Sqrt(2)/3+1), 0, imaging.NearestNeighbor) // Create the Gift filter filter := gift.New( gift.Rotate(45, color.Transparent, gift.LinearInterpolation), ) bounds := filter.Bounds(topFlat.Bounds()) top := image.NewNRGBA(bounds) // Draw it on the filter, then smush it! filter.Draw(top, topFlat) top = imaging.Resize(top, width+2, width/3, imaging.NearestNeighbor) // Skew the front and sides at 15 degree angles to match up with the // head that has been smushed front := skin.cropHead(skin.Image).(*image.NRGBA) side := imaging.Crop(skin.Image, image.Rect(0, 8, 8, 16)) front = imaging.Resize(front, width/2, int(float64(width)/1.75), imaging.NearestNeighbor) side = imaging.Resize(side, width/2, int(float64(width)/1.75), imaging.NearestNeighbor) front = skewVertical(front, math.Pi/12) side = skewVertical(imaging.FlipH(side), math.Pi/-12) // Create a new image to assemble upon skin.Processed = image.NewNRGBA(image.Rect(0, 0, width, width)) // Draw each side draw.Draw(skin.Processed.(draw.Image), image.Rect(0, width/6, width/2, width), side, image.Pt(0, 0), draw.Src) draw.Draw(skin.Processed.(draw.Image), image.Rect(width/2, width/6, width, width), front, image.Pt(0, 0), draw.Src) // Draw the top we created draw.Draw(skin.Processed.(draw.Image), image.Rect(-1, 0, width+1, width/3), top, image.Pt(0, 0), draw.Over) return nil }
// transformImage modifies the image m based on the transformations specified // in opt. func transformImage(m image.Image, opt Options) image.Image { // resize if needed if w, h, resize := resizeParams(m, opt); resize { if opt.Fit { m = imaging.Fit(m, w, h, resampleFilter) } else { if w == 0 || h == 0 { m = imaging.Resize(m, w, h, resampleFilter) } else { m = imaging.Resize(m, w, h, imaging.Lanczos) } } } // flip if opt.FlipVertical { m = imaging.FlipV(m) } if opt.FlipHorizontal { m = imaging.FlipH(m) } // rotate switch opt.Rotate { case 90: m = imaging.Rotate90(m) case 180: m = imaging.Rotate180(m) case 270: m = imaging.Rotate270(m) } return m }
func generateThumbnailImage(img image.Image, thumbnailPath string, width int, height int) { thumbWidth := float64(utils.Cfg.FileSettings.ThumbnailWidth) thumbHeight := float64(utils.Cfg.FileSettings.ThumbnailHeight) imgWidth := float64(width) imgHeight := float64(height) var thumbnail image.Image if imgHeight < thumbHeight && imgWidth < thumbWidth { thumbnail = img } else if imgHeight/imgWidth < thumbHeight/thumbWidth { thumbnail = imaging.Resize(img, 0, utils.Cfg.FileSettings.ThumbnailHeight, imaging.Lanczos) } else { thumbnail = imaging.Resize(img, utils.Cfg.FileSettings.ThumbnailWidth, 0, imaging.Lanczos) } buf := new(bytes.Buffer) if err := jpeg.Encode(buf, thumbnail, &jpeg.Options{Quality: 90}); err != nil { l4g.Error(utils.T("api.file.handle_images_forget.encode_jpeg.error"), thumbnailPath, err) return } if err := WriteFile(buf.Bytes(), thumbnailPath); err != nil { l4g.Error(utils.T("api.file.handle_images_forget.upload_thumb.error"), thumbnailPath, err) return } }
// Extracts thumbnail func (c *Convertor) ExtractThumbnail(file string, info os.FileInfo) { c.CurrFile += 1 cover, err := c.GetCoverImage(file, info) if err != nil { fmt.Fprintf(os.Stderr, "Error GetCoverImage: %v\n", err.Error()) return } if err != nil { fmt.Fprintf(os.Stderr, "Error Thumbnail: %v\n", err.Error()) return } if c.Opts.Width > 0 || c.Opts.Height > 0 { if c.Opts.Fit { cover = imaging.Fit(cover, c.Opts.Width, c.Opts.Height, filters[c.Opts.Filter]) } else { cover = imaging.Resize(cover, c.Opts.Width, c.Opts.Height, filters[c.Opts.Filter]) } } else { cover = imaging.Resize(cover, 256, 0, filters[c.Opts.Filter]) } imagick.Initialize() mw := imagick.NewMagickWand() defer mw.Destroy() b := new(bytes.Buffer) png.Encode(b, cover) err = mw.ReadImageBlob(b.Bytes()) if err != nil { fmt.Fprintf(os.Stderr, "Error ReadImageBlob: %v\n", err.Error()) } var fileuri string var filename string if c.Opts.Outfile == "" { fileuri = "file://" + file filename = filepath.Join(c.Opts.Outdir, fmt.Sprintf("%x.png", md5.Sum([]byte(fileuri)))) } else { abs, _ := filepath.Abs(c.Opts.Outfile) fileuri = "file://" + abs filename = abs } mw.SetImageFormat("PNG") mw.SetImageProperty("Software", "CBconvert") mw.SetImageProperty("Description", "Thumbnail of "+fileuri) mw.SetImageProperty("Thumb::URI", fileuri) mw.SetImageProperty("Thumb::MTime", strconv.FormatInt(info.ModTime().Unix(), 10)) mw.SetImageProperty("Thumb::Size", strconv.FormatInt(info.Size(), 10)) mw.SetImageProperty("Thumb::Mimetype", mime.TypeByExtension(filepath.Ext(file))) mw.WriteImage(filename) }
// Extracts cover func (c *Convertor) ExtractCover(file string, info os.FileInfo) { c.CurrFile += 1 cover, err := c.GetCoverImage(file, info) if err != nil { fmt.Fprintf(os.Stderr, "Error GetCoverImage: %v\n", err.Error()) return } if c.Opts.Width > 0 || c.Opts.Height > 0 { if c.Opts.Fit { cover = imaging.Fit(cover, c.Opts.Width, c.Opts.Height, filters[c.Opts.Filter]) } else { cover = imaging.Resize(cover, c.Opts.Width, c.Opts.Height, filters[c.Opts.Filter]) } } filename := filepath.Join(c.Opts.Outdir, fmt.Sprintf("%s.jpg", c.getBasename(file))) f, err := os.Create(filename) if err != nil { fmt.Fprintf(os.Stderr, "Error Create: %v\n", err.Error()) return } defer f.Close() jpeg.Encode(f, cover, &jpeg.Options{c.Opts.Quality}) }
func ResizeHandler(w http.ResponseWriter, r *http.Request) { // parse url vars v := mux.Vars(r) width, _ := v["width"] height, _ := v["height"] x, _ := strconv.Atoi(width) y, _ := strconv.Atoi(height) imageUrl, _ := v["imageUrl"] m := getImg(imageUrl) cropBox, _ := getFillCrop(m, float32(x)/float32(y)) cropRect := image.Rect(cropBox.X, cropBox.Y, cropBox.X+cropBox.Width, cropBox.Y+cropBox.Height) croppedImg := imaging.Crop(m, cropRect) // convert to opencv image //srcImage := opencv.FromImage(m) //if srcImage == nil { // fmt.Printf("Couldn't create opencv Image") //} //defer srcImage.Release() //croppedImage := opencv.Crop(srcImage, cropBox.X, cropBox.Y, cropBox.Width, cropBox.Height) //resizedImage := opencv.Resize(croppedImage, x, y, opencv.CV_INTER_LINEAR) resizedImage := imaging.Resize(croppedImg, x, y, imaging.CatmullRom) jpeg.Encode(w, resizedImage, &jpeg.Options{Quality: 90}) }
func decodeFunc(h []string) func(rec []string) (draw.Image, error) { if h[0] == "ImageId" { return decodePGM } if h[0] == "left_eye_center_x" { return func(rec []string) (draw.Image, error) { src, err := decodePGM(rec) if err != nil { return nil, err } b := src.Bounds() img := image.NewRGBA(b) draw.Draw(img, b, src, b.Min, draw.Src) for i := 0; i < len(rec)/2; i++ { /* x, err := strconv.ParseFloat(rec[2*i], 64) if err != nil { log.Print(err) continue } y, err := strconv.ParseFloat(rec[2*i + 1], 64) if err != nil { log.Print(err) continue } img.Set(int(x + 0.5), int(y + 0.5), color.RGBA{0xff, 0, 0, 0xff})*/ } // overlayPoints( i := imaging.Resize(img, 500, 0, imaging.Lanczos) return i, nil } } return nil }
func Resized(ext string, data []byte, width, height int) (resized []byte, w int, h int) { if width == 0 && height == 0 { return data, 0, 0 } srcImage, _, err := image.Decode(bytes.NewReader(data)) if err == nil { bounds := srcImage.Bounds() var dstImage *image.NRGBA if bounds.Dx() > width && width != 0 || bounds.Dy() > height && height != 0 { if width == height && bounds.Dx() != bounds.Dy() { dstImage = imaging.Thumbnail(srcImage, width, height, imaging.Lanczos) w, h = width, height } else { dstImage = imaging.Resize(srcImage, width, height, imaging.Lanczos) } } else { return data, bounds.Dx(), bounds.Dy() } var buf bytes.Buffer switch ext { case ".png": png.Encode(&buf, dstImage) case ".jpg", ".jpeg": jpeg.Encode(&buf, dstImage, nil) case ".gif": gif.Encode(&buf, dstImage, nil) } return buf.Bytes(), dstImage.Bounds().Dx(), dstImage.Bounds().Dy() } else { glog.Error(err) } return data, 0, 0 }
func (api *Api) Resize(imgloc string, xsize, ysize int, resizeType string) bool { dest := setSize(imgloc, xsize, ysize) if _, err := os.Stat(dest); err == nil { return true } bts, err := ioutil.ReadFile(imgloc) if err != nil { fmt.Println(err) return false } rdr := bytes.NewReader(bts) i, _, err := image.Decode(rdr) if err != nil { fmt.Println(err) return false } var fsimg *image.NRGBA switch resizeType { case "fit": fsimg = imaging.Fit(i, xsize, ysize, imaging.Lanczos) case "thumb": fsimg = imaging.Thumbnail(i, xsize, ysize, imaging.Lanczos) default: fsimg = imaging.Resize(i, xsize, ysize, imaging.Lanczos) } out, err := os.Create(dest) if err != nil { return false } defer out.Close() jpeg.Encode(out, fsimg, nil) return true }
func CenterCrop(img *io.Reader, width, height int) ([]byte, error) { m, _, err := image.Decode(*img) if err != nil { return nil, err } // TODO: I probably can switch to using imaging.Thumbnail here. imgW := float64(m.Bounds().Max.X - m.Bounds().Min.X) imgH := float64(m.Bounds().Max.Y - m.Bounds().Min.Y) targetW := float64(width) targetH := float64(height) var scale float64 if imgW*targetH > targetW*imgH { scale = targetH / imgH } else { scale = targetW / imgW } m = imaging.Resize(m, int(imgW*scale), int(imgH*scale), imaging.Lanczos) m = imaging.CropCenter(m, width, height) buf := new(bytes.Buffer) jpeg.Encode(buf, m, &jpeg.Options{Quality: 95}) return buf.Bytes(), nil }
func (image *Image) resizePreview(errorChan chan error, srcImage image.Image) { size := srcImage.Bounds().Size() ratio := float64(size.Y) / float64(size.X) targetHeight := int(float64(widthPreview) * ratio) dstImage := imaging.Resize(srcImage, widthPreview, targetHeight, imaging.Lanczos) dest := "./data/images/preview/" + image.Location errorChan <- imaging.Save(dstImage, dest) }
func resizeImage(filename string, size int) string { resizedFile := filename + ".resized.png" img, err := imaging.Open(filename) if err != nil { panic(err) } dstimg := imaging.Resize(img, size, 0, imaging.Box) imaging.Save(dstimg, resizedFile) return resizedFile }
/* resize when there is no height constraint, otherwise crop */ func (result *imageInfo) resizeOrCrop(img image.Image, width int, height int) image.Image { var imgdata image.Image if height == 0 { imgdata = imaging.Resize(img, width, height, imaging.Lanczos) } else { imgdata = imaging.CropCenter(img, width, height) } result.width = imgdata.Bounds().Max.X result.height = imgdata.Bounds().Max.Y return imgdata }
func (be *Backend) GenerateThumbnail(bin string, filename string, width int, height int, crop bool) error { f, err := be.GetFileMetaData(bin, filename) if err != nil { return err } if strings.Split(f.MIME, "/")[0] != "image" { return errors.New("Batch job skipped: " + filename + " is not an image") } fpath := filepath.Join(be.filedir, bin, filename) cachedir := filepath.Join(be.filedir, bin, ".cache") if !isDir(cachedir) { if err := os.Mkdir(cachedir, 0700); err != nil { return err } } dst := filepath.Join(cachedir, strconv.Itoa(width)+"x"+strconv.Itoa(height)+"-"+filename) // Optimize to skip thumbnail generation if the thumbnail file exists // and is newer than the file. fi, err := os.Lstat(dst) if err == nil { if f.CreatedAt.After(fi.ModTime()) { // File newer than thumbnail. Ok to generate. } else { // File older than thumbnail. No need to generate. return nil } } s, err := imaging.Open(fpath) if err != nil { return err } if crop { im := imaging.Fill(s, width, height, imaging.Center, imaging.Lanczos) err = imaging.Save(im, dst) } else { im := imaging.Resize(s, width, height, imaging.Lanczos) err = imaging.Save(im, dst) } f.Links = be.GenerateLinks(f.Bin, f.Filename) be.Lock() defer be.Unlock() id := bin + filename delete(be.files, id) be.files[id] = f return err }
func normalizeInput(input image.Image, maxSize int) (image.Image, float64, error) { var scale float64 if input.Bounds().Dx() > maxSize { scale = float64(input.Bounds().Dx()) / float64(maxSize) } else { scale = float64(input.Bounds().Dy()) / float64(maxSize) } log.Printf("Normalizing to %dx%d\n", int(float64(input.Bounds().Dx())/scale), int(float64(input.Bounds().Dy())/scale)) resized := imaging.Resize(input, int(float64(input.Bounds().Dx())/scale), int(float64(input.Bounds().Dy())/scale), imaging.Lanczos) return resized, scale, nil }
func MakeFromImage(srcImage image.Image, t string, w, h int) (image *image.NRGBA, err error) { switch t { case "thumbnail": image = imaging.Thumbnail(srcImage, w, h, imaging.Lanczos) case "resize": image = imaging.Resize(srcImage, w, h, imaging.Lanczos) case "fit": image = imaging.Fit(srcImage, w, h, imaging.Lanczos) default: image = imaging.Thumbnail(srcImage, w, h, imaging.Lanczos) } return image, nil }
func thumbs(args []string, thumbSizes []int) { if newThumbsSizes != "" { vals := strings.Split(newThumbsSizes, ",") thumbSizes = make([]int, len(vals)) for i := 0; i < len(vals); i++ { numstr := strings.TrimSpace(vals[i]) if numstr == "" { thumbSizes[i] = 0 continue } num, err := strconv.Atoi(numstr) if err != nil { log.Print(err) continue } thumbSizes[i] = num } } for i := 0; i < len(args); i++ { file := args[i] ext := filepath.Ext(file) _, err := os.Stat(file) if err != nil { log.Fatal("file " + file + " is not accessible") } img, err := imaging.Open(file) if err != nil { log.Fatal(err) } for j := 0; j < len(thumbSizes); j++ { if thumbSizes[j] == 0 { continue } resized := imaging.Resize(img, thumbSizes[j], 0, imaging.Lanczos) rect := resized.Bounds().Max out := fmt.Sprintf("%s_%dx%d%s", strings.TrimSuffix(file, ext), rect.X, rect.Y, ext) err = imaging.Save(resized, out) log.Println("saved " + out) if err != nil { log.Fatal(err) } } } }
func Resize(src io.Reader, c *CacheContext) (io.Reader, error) { raw, err := ioutil.ReadAll(src) if err != nil { return nil, err } width := c.Width data := bytes.NewReader(raw) img, format, err := image.Decode(data) if err != nil { return nil, err } var resizedImage image.NRGBA if c.Crop { minDimension := int(math.Min(float64(img.Bounds().Size().X), float64(img.Bounds().Size().Y))) if minDimension < c.Width || c.Width == 0 { width = minDimension } resizedImage = *imaging.Fill(img, width, width, imaging.Center, imaging.Lanczos) } else { resizedImage = *imaging.Resize(img, width, 0, imaging.Lanczos) } buf := new(bytes.Buffer) var imgFormat imaging.Format switch format { case "png": imgFormat = imaging.PNG case "jpeg": imgFormat = imaging.JPEG case "tiff": imgFormat = imaging.TIFF case "bmp": imgFormat = imaging.BMP default: return nil, errors.New("unsupported image format") } err = imaging.Encode(buf, resizedImage.SubImage(resizedImage.Rect), imgFormat) if err != nil { return nil, err } return buf, err }
func fitCropScale(i image.Image, r image.Rectangle) image.Image { wantRatio := float64(r.Bounds().Dx()) / float64(r.Bounds().Dy()) haveRatio := float64(i.Bounds().Dx()) / float64(i.Bounds().Dy()) sliceRect := image.Rectangle{} if haveRatio > wantRatio { wantwidth := wantRatio * float64(i.Bounds().Dy()) sliceRect = image.Rect(i.Bounds().Dx()/2-int(wantwidth/2), 0, i.Bounds().Dx()/2+int(wantwidth/2), i.Bounds().Dy()) } else { wantheight := float64(i.Bounds().Dx()) / wantRatio sliceRect = image.Rect(0, i.Bounds().Dy()/2-int(wantheight/2), i.Bounds().Dx(), i.Bounds().Dy()/2+int(wantheight/2)) } return imaging.Resize(imaging.Crop(i, sliceRect), r.Dx(), r.Dy(), imaging.Lanczos) }
func (h *ImgHandler) handlePOST(w http.ResponseWriter, req *http.Request) { s := MgoSession.Copy() defer s.Close() name, path := h.convertPath(req.URL.Path) document, _ := new(Document).Find(s, name, path) document.Name = name document.Path = path origin, format, err := image.Decode(req.Body) if err != nil { log.Panicln(err) io.WriteString(w, err.Error()) return } // image is larger than the specified stored size, we need to resize it var img image.Image if (Configuration.StoredSize.Width > 0 && origin.Bounds().Dx() > Configuration.StoredSize.Width) || (Configuration.StoredSize.Height > 0 && origin.Bounds().Dy() > Configuration.StoredSize.Height) { img = imaging.Resize(origin, Configuration.StoredSize.Width, Configuration.StoredSize.Height, imaging.CatmullRom) } else { img = origin } buf := new(bytes.Buffer) err = h.writeImage(buf, img, format) if err != nil { log.Panicln(err) io.WriteString(w, err.Error()) return } document.Binary = buf.Bytes() contentType := req.Header.Get("Content-Type") if contentType != "" { document.ContentType = contentType } err = document.Save(s) if err != nil { log.Panicln(err) io.WriteString(w, err.Error()) } else { io.WriteString(w, "stored\n") } }
// GetHash returns a phash string for a JPEG image func GetHash(reader io.Reader) (string, error) { image, err := imaging.Decode(reader) if err != nil { return "", err } image = imaging.Resize(image, 32, 32, imaging.Lanczos) image = imaging.Grayscale(image) imageMatrixData := getImageMatrix(image) dctMatrix := getDCTMatrix(imageMatrixData) smallDctMatrix := reduceMatrix(dctMatrix, 8) dctMeanValue := calculateMeanValue(smallDctMatrix) return buildHash(smallDctMatrix, dctMeanValue), nil }
//缩放 func (this *Image) resize(filename string, w, h, s int) (string, error) { if this.source == nil { if err := this.open(filename); err != nil { return "", err } } var dst *image.NRGBA dst = imaging.Resize(this.source, w, h, imaging.CatmullRom) //取目标文件名 dstfile, err := this.dstFilename(s) if err != nil { return "", err } //保存文件 return dstfile, imaging.Save(dst, dstfile) }
//Resize with mode plain. Does the acutal resizing and returns the image //errors only if dstWidth or dstHeight is invalid func (p PlainResizer) Resize(input image.Image, dstWidth, dstHeight int) (image.Image, error) { if dstWidth < 0 && dstHeight < 0 { return nil, fmt.Errorf("Either width or height must be greater zero to keep the existing ratio") } //since we use -1 as optional and imaging uses zero as optional //we change -1 to 0 to keep the aspect ratio if dstWidth < 0 { dstWidth = 0 } if dstHeight < 0 { dstHeight = 0 } return imaging.Resize(input, dstWidth, dstHeight, imaging.Lanczos), nil }
func Benchmark(img image.Image, rounds int, targets ...Size) (results Results) { var ( t time.Time Δt time.Duration ) results = make(map[string]map[Size]Result) for name, filter := range filters { results[name] = make(map[Size]Result) for _, target := range targets { var ( r Result // The result for this filter and size. total time.Duration ) for i := 0; i < rounds; i++ { // Take resizing time resize: t = time.Now() imaging.Resize(img, target[0], target[1], filter) Δt = time.Since(t) // FIXME: // For some reason NearestNeighbor sometimes gets zero duration. // If this happens, we'll just try again, I guess. if Δt == 0 { goto resize } // Set min & max if need be. if r.Min == 0 || Δt < r.Min { r.Min = Δt } if Δt > r.Max { r.Max = Δt } // Accumulate total time. total += Δt } // Calculate average resize time. r.Avg = total / time.Duration(rounds) // Append to the results results[name][target] = r } } return }
func ResampleImage(src image.Image, w int, h int) (image.Image, error) { sw := src.Bounds().Dx() sh := src.Bounds().Dy() sr := float32(sw) / float32(sh) if w > sw { w = sw } if h > sh { h = sh } if w == 0 && h == 0 { return src, nil } else if w == 0 { w = int(float32(h) * sr) } else if h == 0 { h = (int)(float32(w) / sr) } x := 0 y := 0 nw := sw nh := sh ratio := float32(sw) / float32(sh) outputRatio := float32(w) / float32(h) if math.Abs(float64(ratio-outputRatio)) > 0.1 { if ratio < outputRatio { nh = int(float32(nw) / outputRatio) y = (sh - nh) / 2.0 } else { nw = int(float32(nh) * outputRatio) x = (sw - nw) / 2.0 } rect := image.Rect(x, y, x+nw, y+nh) src = SubImage(src, rect) log.Info(src.Bounds(), ratio, outputRatio) } dst := imaging.Resize(src, w, h, imaging.Lanczos) return dst, nil }
func (i *Image) Draw() image.Image { if i.canvas != nil && i.upToDate { return i.canvas } m, err := imaging.Open(i.href) if err != nil { return image.Transparent } if i.width|i.height != 0 { m = imaging.Resize(m, i.width, i.height, i.filter) } size := m.Bounds().Size() i.setDimensions(size.X, size.Y) return m }
//Resize with mode fit. Does the acutal resizing and returns the image //errors only if dstWidth or dstHeight is invalid func (f FitResizer) Resize(input image.Image, dstWidth, dstHeight int) (image.Image, error) { if dstWidth < 0 || dstHeight < 0 { return nil, fmt.Errorf("Please specify both width and height for your target image") } originalBounds := input.Bounds() originalRatio := float64(originalBounds.Dx()) / float64(originalBounds.Dy()) targetRatio := float64(dstWidth) / float64(dstHeight) if targetRatio < originalRatio { dstHeight = int(float64(dstWidth) / originalRatio) } else { dstWidth = int(float64(dstHeight) * originalRatio) } return imaging.Resize(input, int(dstWidth), int(dstHeight), imaging.Lanczos), nil }
func (f *File) GenerateImage(width int, height int, crop bool) error { fpath := filepath.Join(f.TagDir, f.Filename) s, err := imaging.Open(fpath) if err != nil { return err } if crop { im := imaging.Fill(s, width, height, imaging.Center, imaging.Lanczos) err = imaging.Save(im, f.ImagePath(width, height)) } else { im := imaging.Resize(s, width, height, imaging.Lanczos) err = imaging.Save(im, f.ImagePath(width, height)) } return err }
func MakeFromReader(reader io.Reader, t string, w, h int) (image *image.NRGBA, err error) { srcImage, err := Open(reader) if err != nil { return nil, err } switch t { case "thumbnail": image = imaging.Thumbnail(srcImage, w, h, imaging.Lanczos) case "resize": image = imaging.Resize(srcImage, w, h, imaging.Lanczos) case "fit": image = imaging.Fit(srcImage, w, h, imaging.Lanczos) default: image = imaging.Thumbnail(srcImage, w, h, imaging.Lanczos) } return }
func mergeTextures(normalTexture, litTexture *image.NRGBA) { normSize := normalTexture.Bounds().Size() litSize := litTexture.Bounds().Size() if normSize.X != litSize.X || normSize.Y != litSize.Y { //Größen sind unterschiedlich --> normale Textur auf Größe der Nachttextur skalieren normalTexture = imaging.Resize(normalTexture, litSize.X, litSize.Y, imaging.Linear) } for x := 0; x < litSize.X; x++ { for y := 0; y < litSize.Y; y++ { i := y*normalTexture.Stride + x*4 j := y*litTexture.Stride + x*4 litTexture.Pix[j+0] = mergePixel(normalTexture.Pix[i+0], litTexture.Pix[j+0], 1.0) litTexture.Pix[j+1] = mergePixel(normalTexture.Pix[i+1], litTexture.Pix[j+1], 1.0) litTexture.Pix[j+2] = mergePixel(normalTexture.Pix[i+2], litTexture.Pix[j+2], 0.7) litTexture.Pix[j+3] = normalTexture.Pix[i+3] } } }