// 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 }
func (ipo *ImageProcessorOptions) ProcessImage(source *Image) (*Image, error) { dest := &Image{format: source.format} var wip image.Image if ipo.ScaleX == -1 { wip = imaging.FlipH(source.image) } else { wip = source.image } if ipo.X != 0 || ipo.Y != 0 || ipo.Width != source.Width() || ipo.Height != source.Height() { r := image.Rectangle{image.Point{int(ipo.X), int(ipo.Y)}, image.Point{int(ipo.X + ipo.Width), int(ipo.Y + ipo.Height)}} wip = imaging.Crop(wip, r) } var err error switch dest.format { case JPEG: err = jpeg.Encode(&dest.buffer, wip, &jpeg.Options{int(ipo.Quality)}) case PNG: err = png.Encode(&dest.buffer, wip) default: return nil, errors.New("attempt to encode to unsupported image format") } return dest, err }
// Returns the legs. func (skin *mcSkin) renderLowerBody() *image.NRGBA { // This will be the base. lowerBodyImg := image.NewNRGBA(image.Rect(0, 0, LlWidth+RlWidth, LlHeight)) rlImg := imaging.Crop(skin.Image, image.Rect(RlX, RlY, RlX+RlWidth, RlY+RlHeight)) // If it's an old skin, they don't have a Left Leg, so we'll just flip their right. var llImg image.Image if skin.is18Skin() { llImg = imaging.Crop(skin.Image, image.Rect(LlX, LlY, LlX+LlWidth, LlY+LlHeight)) } else { llImg = imaging.FlipH(rlImg) } return skin.drawLower(lowerBodyImg, rlImg, llImg.(*image.NRGBA)) }
func Extract(img image.Image, name string, X, Y, W, H float32, rotated bool) error { dst := imaging.Crop(img, image.Rect(int(X), int(Y), int(X+W), int(Y+H))) if rotated { log.Fatal("图片被旋转过") } return imgutil.SaveImg(name, dst) }
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}) }
// Returns the head of the skin image overlayed with the helm. func (skin *mcSkin) cropHelm(img image.Image) image.Image { headImg := skin.cropHead(img) helmImg := imaging.Crop(img, image.Rect(HelmX, HelmY, HelmX+HeadWidth, HelmY+HeadHeight)) skin.removeAlpha(helmImg) fastDraw(headImg.(*image.NRGBA), helmImg, 0, 0) return headImg }
// Returns the legs but with any armor which the user has. func (skin *mcSkin) renderLowerArmor() *image.NRGBA { // This will be the base. lowerArmorBodyImg := skin.renderLowerBody() // If it's an old skin, they don't have armor here. if skin.is18Skin() { // Get the armor layers from the skin and remove the Alpha. ll2Img := imaging.Crop(skin.Image, image.Rect(Ll2X, Ll2Y, Ll2X+LlWidth, Ll2Y+LlHeight)) skin.removeAlpha(ll2Img) rl2Img := imaging.Crop(skin.Image, image.Rect(Rl2X, Rl2Y, Rl2X+RlWidth, Rl2Y+RlHeight)) skin.removeAlpha(rl2Img) return skin.drawLower(lowerArmorBodyImg, ll2Img, rl2Img) } return lowerArmorBodyImg }
// Returns the torso and arms. func (skin *mcSkin) renderUpperBody() *image.NRGBA { // This will be the base. upperBodyImg := image.NewNRGBA(image.Rect(0, 0, LaWidth+TorsoWidth+RaWidth, TorsoHeight)) torsoImg := imaging.Crop(skin.Image, image.Rect(TorsoX, TorsoY, TorsoX+TorsoWidth, TorsoY+TorsoHeight)) raImg := imaging.Crop(skin.Image, image.Rect(RaX, RaY, RaX+RaWidth, RaY+TorsoHeight)) // If it's an old skin, they don't have a Left Arm, so we'll just flip their right. var laImg image.Image if skin.is18Skin() { laImg = imaging.Crop(skin.Image, image.Rect(LaX, LaY, LaX+LaWidth, LaY+TorsoHeight)) } else { laImg = imaging.FlipH(raImg) } return skin.drawUpper(upperBodyImg, torsoImg, raImg, laImg.(*image.NRGBA)) }
func resizeThumbnail(from *bytes.Buffer, spec *ThumbnailSpec) (to io.Reader, w int, h int, err error) { src, name, err := image.Decode(from) if err != nil { return } srcB := src.Bounds() var dst image.Image if spec.CropToSquare && srcB.Dx() != srcB.Dy() { var rect image.Rectangle if srcB.Dx() > srcB.Dy() { x1 := (srcB.Dx() - srcB.Dy()) / 2 x2 := srcB.Dx() - x1 rect = image.Rect(x1, 0, x2, srcB.Dy()) } else { rect = image.Rect(0, 0, srcB.Dx(), srcB.Dx()) } w = spec.Height if (spec.Height > spec.Width && spec.Width != 0) || spec.Height == 0 { w = spec.Width } h = w cropedImg := imaging.Crop(src, rect) rect = cropedImg.Bounds() dst = resize.Resize(cropedImg, rect, w, h) } else { w, h = spec.CalculateRect(srcB, spec.CropToSquare) if w >= srcB.Dx() || h >= srcB.Dy() { w, h = srcB.Dx(), srcB.Dy() } rect := image.Rect(0, 0, srcB.Dx(), srcB.Dy()) dst = resize.Resize(src, rect, w, h) } var buf bytes.Buffer switch name { case "jpeg": jpeg.Encode(&buf, dst, &jpeg.Options{95}) case "png": png.Encode(&buf, dst) case "gif": jpeg.Encode(&buf, dst, &jpeg.Options{95}) case "bmp": jpeg.Encode(&buf, dst, &jpeg.Options{95}) } to = &buf return }
// Returns the torso and arms but with any armor which the user has. func (skin *mcSkin) renderUpperArmor() *image.NRGBA { // This will be the base. upperArmorBodyImg := skin.renderUpperBody() // If it's an old skin, they don't have armor here. if skin.is18Skin() { // Get the armor layers from the skin and remove the Alpha. torso2Img := imaging.Crop(skin.Image, image.Rect(Torso2X, Torso2Y, Torso2X+TorsoWidth, Torso2Y+TorsoHeight)) skin.removeAlpha(torso2Img) la2Img := imaging.Crop(skin.Image, image.Rect(La2X, La2Y, La2X+LaWidth, La2Y+TorsoHeight)) skin.removeAlpha(la2Img) ra2Img := imaging.Crop(skin.Image, image.Rect(Ra2X, Ra2Y, Ra2X+RaWidth, Ra2Y+TorsoHeight)) skin.removeAlpha(ra2Img) return skin.drawUpper(upperArmorBodyImg, torso2Img, ra2Img, la2Img) } return upperArmorBodyImg }
func (imageHandler) Handle(media MediaLibrary, file multipart.File, option *Option) error { if err := media.Store(media.URL("original"), option, file); err == nil { file.Seek(0, 0) if img, err := imaging.Decode(file); err == nil { if format, err := getImageFormat(media.URL()); err == nil { if cropOption := media.GetCropOption("original"); cropOption != nil { img = imaging.Crop(img, *cropOption) } // Save default image var buffer bytes.Buffer imaging.Encode(&buffer, img, *format) media.Store(media.URL(), option, &buffer) for key, size := range media.GetSizes() { newImage := img if cropOption := media.GetCropOption(key); cropOption != nil { newImage = imaging.Crop(newImage, *cropOption) } dst := imaging.Thumbnail(newImage, size.Width, size.Height, imaging.Lanczos) var buffer bytes.Buffer imaging.Encode(&buffer, dst, *format) media.Store(media.URL(key), option, &buffer) } return nil } else { return err } } else { return err } } else { return err } }
func Create(c *gin.Context) { file, fileHeader, err := c.Request.FormFile("file") if err != nil { c.Error(err) return } _, h := parseVal("h", c) _, w := parseVal("w", c) _, x := parseVal("x", c) _, y := parseVal("y", c) img, _, err := image.Decode(file) if err != nil { c.Error(err) return } log.Debug("Crop w:%v h:%v x:%v y:%v", w, h, x, y) rect := convertToRectangle(int(w), int(h), int(x), int(y)) log.Debug("Rect", rect) croppedImg := imaging.Crop(img, rect) db := utils.GetDb(c) gridFile, err := db.GridFS("fs").Create(fileHeader.Filename) if err != nil { c.Error(err) return } buffer := new(bytes.Buffer) jpeg.Encode(buffer, croppedImg, nil) gridFile.SetName(fileHeader.Filename) gridFile.SetContentType(fileHeader.Header.Get("Content-Type")) _, err = io.Copy(gridFile, buffer) if err != nil { c.Error(err) return } file.Close() gridFile.Close() c.JSON(http.StatusOK, gin.H{"_id": gridFile.Id()}) }
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 (i *ImgNet) cut(p image.Point, img *image.Image) []float64 { rect := image.Rect(p.X, p.Y, p.X+i.w, p.Y+i.h) croppedImg := imaging.Crop(*img, rect) rgb := make([]float64, i.w*i.h*3) for y := 0; y < croppedImg.Bounds().Dy(); y++ { for x := 0; x < croppedImg.Bounds().Dx(); x++ { r, g, b, _ := croppedImg.At(x, y).RGBA() index := x + y*i.w*3 rgb[index] = float64(r) / 65535 rgb[index+1] = float64(g) / 65535 rgb[index+2] = float64(b) / 65535 } } return rgb }
func NewCubemap(name string, baseImage image.Image, lod bool) *CubeMap { cubeMap := new(CubeMap) x := baseImage.Bounds().Max.X y := baseImage.Bounds().Max.Y cubeMap.Name = name cubeMap.Lod = lod cubeMap.Right = imaging.Crop(baseImage, image.Rect(x/2, y/3, 3*x/4, 2*y/3)) cubeMap.Left = imaging.Crop(baseImage, image.Rect(0, y/3, x/4, 2*y/3)) cubeMap.Top = imaging.Crop(baseImage, image.Rect(x/4, 0, x/2, y/3)) cubeMap.Bottom = imaging.Crop(baseImage, image.Rect(x/4, 2*y/3, x/2, y)) cubeMap.Back = imaging.Crop(baseImage, image.Rect(3*x/4, y/3, x, 2*y/3)) cubeMap.Front = imaging.Crop(baseImage, image.Rect(x/4, y/3, x/2, 2*y/3)) return cubeMap }
func MakeImages(rect *image.Rectangle, file io.Reader) ([]*bytes.Buffer, error) { runtime.GOMAXPROCS(runtime.NumCPU()) ar := aspectRatio(rect) if ar < RATIO { return nil, fmt.Errorf("makeImages: aspect ratio is too small") } else if ar > RATIO { cropRatio(rect) } img, _, err := image.Decode(file) if err != nil { return nil, err } img = imaging.Clone(img) top := rect.Min.Y square := squareHeight(rect) space := spaceHeight(rect) buffers := make([]*bytes.Buffer, 5, 5) for i := 0; i < 5; i++ { new_rect := image.Rect(rect.Min.X, top, rect.Max.X, top+square) new_img := imaging.Crop(img, new_rect) buffers[i] = bytes.NewBuffer(make([]byte, 0)) err = png.Encode(buffers[i], new_img) if err != nil { panic(err) } top = top + square + space } return buffers, nil }
// Process begins the process of loading the source image, partitioning it, and // determining all of the unique images. Once complete, it produces a report // which is written to a file called report.html in the current directory. func (p *ImageSet) Process() { sourceImage := p.getSourceImage() if sourceImage == nil { return } bounds := sourceImage.Bounds() numX, numY := calculateNumberImages(bounds) p.stride = numX p.images = make([]uint64, numX*numY) p.orientations = make([]byte, numX*numY) for y := 0; y < numY; y++ { for x := 0; x < numX; x++ { bounds := image.Rect(x*128, y*128, (x+1)*128, (y+1)*128) p.AddImage(imaging.Crop(sourceImage, bounds), x, y) } } p.WriteImageFiles() p.WriteReport(bounds) }
// Do performs the resize func Do(r io.Reader, w io.Writer, crop *image.Rectangle, width, height int) error { // read it img, err := imaging.Decode(r) if err != nil { return err } // if crop isn't nil if crop != nil { // then crop it img = imaging.Crop(img, *crop) } // resize it img = imaging.Resize(img, width, height, imaging.MitchellNetravali) // write it if err := imaging.Encode(w, img, imaging.PNG); err != nil { return err } return nil }
func SaveAndCropImage(isCreate bool) func(scope *gorm.Scope) { return func(scope *gorm.Scope) { for _, field := range scope.Fields() { if media, ok := field.Field.Addr().Interface().(MediaLibrary); ok { option := parseTagOption(field.Tag.Get("media_library")) if media.GetFileHeader() != nil || media.NeedCrop() { var file multipart.File var err error if fileHeader := media.GetFileHeader(); fileHeader != nil { file, err = media.GetFileHeader().Open() } else { file, err = media.Retrieve(media.URL("original")) } if scope.Err(err) != nil { return } if url := media.GetURL(option, scope, field, media); url == "" { scope.Err(errors.New("invalid URL")) } else { result, _ := json.Marshal(map[string]string{"Url": url}) media.Scan(string(result)) } if isCreate && !scope.HasError() { if value, err := media.Value(); err == nil { gorm.Update(scope.New(scope.Value).InstanceSet("gorm:update_attrs", map[string]interface{}{field.DBName: value})) } } if file != nil { defer file.Close() if media.IsImage() { // Save Original Image if scope.Err(media.Store(media.URL("original"), option, file)) == nil { file.Seek(0, 0) // Crop & Resize if img, err := imaging.Decode(file); scope.Err(err) == nil { if format, err := getImageFormat(media.URL()); scope.Err(err) == nil { if cropOption := media.GetCropOption("original"); cropOption != nil { img = imaging.Crop(img, *cropOption) } // Save default image var buffer bytes.Buffer imaging.Encode(&buffer, img, *format) media.Store(media.URL(), option, &buffer) for key, size := range media.GetSizes() { newImage := img if cropOption := media.GetCropOption(key); cropOption != nil { newImage = imaging.Crop(newImage, *cropOption) } dst := imaging.Thumbnail(newImage, size.Width, size.Height, imaging.Lanczos) var buffer bytes.Buffer imaging.Encode(&buffer, dst, *format) media.Store(media.URL(key), option, &buffer) } } } } } else { // Save File scope.Err(media.Store(media.URL(), option, file)) } } } } } } }
// Returns the head of the skin image. func (skin *mcSkin) cropHead(img image.Image) image.Image { return imaging.Crop(img, image.Rect(HeadX, HeadY, HeadX+HeadWidth, HeadY+HeadHeight)) }