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
}
