func CheckDistortion(blob []byte, reffn string, tol float64, resfn string) (err error) { ref := images.NewImage() defer ref.Destroy() err = ref.FromFile(reffn) if err != nil { return errors.New(fmt.Sprintf("Could not load ref image: %v Err: %v", reffn, err)) } img := images.NewImage() defer img.Destroy() err = img.FromBlob(blob) if err != nil { return errors.New(fmt.Sprintf("Could not load blob. Err: %v", err)) } trash, d := img.CompareImages(ref.MagickWand, imagick.METRIC_MEAN_SQUARED_ERROR) trash.Destroy() err = img.WriteImage(filepath.FromSlash(resfn)) if err != nil { return errors.New(fmt.Sprintf("Could not write result file: %v. Err: %v", resfn, err)) } if d > tol { return errors.New(fmt.Sprintf("Too much distortion. res: %v, ref: %v, tol: %v, dist: %v", resfn, reffn, tol, d)) } return }
// Test for right content-type request header func TestMIMEtype(t *testing.T) { s, ln, srverr := startServer() defer stopServer(s, ln, srverr) response := fasthttp.AcquireResponse() request := fasthttp.AcquireRequest() cases := []string{"", "?format=jpeg", "?format=png", "?format=webp", "?format=tiff", "?format=bmp", "?format=gif"} folder := "testimages/server/" for _, c := range cases { request.SetRequestURI(fmt.Sprintf("http://localhost:%d/", port) + folder + "01.jpg" + c) fasthttp.Do(request, response) MIME := string(response.Header.ContentType()) img := images.NewImage() img.FromBlob(response.Body()) expected := "image/" + strings.ToLower(img.GetImageFormat()) if MIME != expected { t.Fatal(fmt.Sprintf("Server returned: %s, image is %s", MIME, expected)) } request.Reset() response.Reset() img.Destroy() } fasthttp.ReleaseRequest(request) fasthttp.ReleaseResponse(response) }
// Get image size func (i ImageSource) ImageSize(fn string) (w int, h int, err error) { i.mutex.RLock() s, ok := i.sizes[fn] i.mutex.RUnlock() if ok { return s[0], s[1], nil } image := images.NewImage() defer image.Destroy() err = i.pingRoots(fn, image) if err != nil { return } w = image.GetWidth() h = image.GetHeight() i.mutex.Lock() i.sizes[fn] = dim{w, h} i.mutex.Unlock() return }
func TestPingRoots(t *testing.T) { logging.Debugf("Testing PingRoots...") is := MakeImageSource() err := is.AddRoot("../") if err != nil { t.Fatal(err) } img := images.NewImage() defer img.Destroy() t0 := time.Now() err = is.searchRoots("testimages/loadimage/22.jpg", img) if err != nil { t.Fatal(err) } t1 := time.Now().Sub(t0) img = images.NewImage() defer img.Destroy() t0 = time.Now() err = is.pingRoots("testimages/loadimage/22.jpg", img) if err != nil { t.Fatal(err) } t2 := time.Now().Sub(t0) img = images.NewImage() defer img.Destroy() t0 = time.Now() err = is.searchRoots("testimages/loadimage/22.jpg", img) if err != nil { t.Fatal(err) } t3 := time.Now().Sub(t0) logging.Debugf("searchRoots #1: %v, pingRoots: %v, searchRoots #2: %v", t1, t2, t3) if t1 < t2 { t.Fatal(fmt.Sprintf("pingRoots is slower than searchRoots! pingRoots: %v, searchRoots: %v", t2, t1)) } if t3 < t2 { t.Fatal(fmt.Sprintf("pingRoots is slower than searchRoots! pingRoots: %v, searchRoots: %v", t2, t3)) } return }
func TestImageWatermark(t *testing.T) { testfolder := "testimages/watermark/" testimage := testfolder + "towatermark.jpg" resfolder := "testresults/images/" tolerance := 0.002 wmimage := images.NewImage() defer wmimage.Destroy() err := wmimage.FromFile(testfolder + "watermark.png") if err != nil { t.Fatal(err) } horizontal := 0.0 vertical := 0.0 cases := []testutils.TestCase{ {testimage, testfolder + "marked1.jpg", resfolder + "marked1.jpg"}, {testimage, testfolder + "marked2.jpg", resfolder + "marked2.jpg"}, {testimage, testfolder + "marked3.jpg", resfolder + "marked3.jpg"}, } for _, c := range cases { img := images.NewImage() defer img.Destroy() err := img.FromFile(c.Testfn) if err != nil { t.Fatal(err) } err = img.Watermark(wmimage, horizontal, vertical) if err != nil { t.Fatal(err) } blob := img.Blob() horizontal = horizontal + 0.5 vertical = vertical + 0.5 err = testutils.CheckDistortion(blob, c.Reffn, tolerance, c.Resfn) if err != nil { t.Fatal(err) } } }
func MakeWatermarker(settings config.Watermark) (wm Watermarker, err error) { image := images.NewImage() err = image.FromFile(settings.ImagePath) if err != nil { return } wm = Watermarker{ WatermarkImage: image, Watermark: settings, } return }
func TestWebroot(t *testing.T) { s := MakeImageSource() s.AddRoot("../") s.AddRoot("https://upload.wikimedia.org/wikipedia/commons/") i := images.NewImage() defer i.Destroy() err := s.LoadImageOp("testimages/loadimage/test.jpg").Apply(i) if err != nil { t.Fatalf("Error loading image from web: %s", err) } i = images.NewImage() defer i.Destroy() err = s.LoadImageOp("b/b4/JPEG_example_JPG_RIP_100.jpg").Apply(i) if err != nil { t.Fatalf("Error loading image from web: %s", err) } if len(i.Blob()) == 0 { t.Fatal("No error, but image is empty.") } }
func CheckImage(blob []byte, c TestCase, tol float64, f func(images.Image) error) (err error) { img := images.NewImage() defer img.Destroy() img.FromBlob(blob) err = f(img) if err != nil { return } err = CheckDistortion(blob, c.Reffn, tol, c.Resfn) if err != nil { return } return }
// Takes an image as a blob and applies the given operations to it // startBlob can be nil, in which case operations should start with an image loading operation func (p ImageProcessor) MakeBlob(startBlob []byte, operations []ops.Operation) ([]byte, error) { p.borrow() defer p.giveBack() img := images.NewImage() defer img.Destroy() if startBlob != nil { img.FromBlob(startBlob) } for _, op := range operations { err := op.Apply(img) if err != nil { return nil, err } } return img.Blob(), nil }