Example #1
0
func (this *FormatProcessor) Process(img *img4g.Image) error {
	log.WithFields(log.Fields{
		"format": this.Format,
	}).Debug("process format")
	err := img.SetFormat(this.Format)
	return err
}
Example #2
0
func getLocation(location int, img *img4g.Image, logo *img4g.Image) (int64, int64, error) {
	var (
		x int64 = 0
		y int64 = 0
	)
	width, height, err := img.Size()
	if err != nil {
		return 0, 0, err
	}
	logowidth, logoheight, err := logo.Size()
	if err != nil {
		return 0, 0, err
	}
	switch location {
	case 1:
		x, y = 0, 0
	case 2:
		x, y = (width-logowidth)/2, 0
	case 3:
		x, y = width-logowidth, 0
	case 4:
		x, y = 0, (height-logoheight)/2
	case 5:
		x, y = (width-logowidth)/2, (height-logoheight)/2
	case 6:
		x, y = width-logowidth, (height-logoheight)/2
	case 7:
		x, y = 0, height-logoheight
	case 8:
		x, y = (width-logowidth)/2, height-logoheight
	case 9:
		x, y = width-logowidth, height-logoheight
	}
	return x, y, nil
}
Example #3
0
func (this *QualityProcessor) Process(img *img4g.Image) error {
	log.WithFields(log.Fields{
		"quality": this.Quality,
	}).Debug("process quality")
	err := img.SetCompressionQuality(this.Quality)
	return err
}
Example #4
0
func (this *WaterMarkProcessor) Process(img *img4g.Image) error {
	l4g.Debug("process watermark")
	var err error = nil
	tran := this.Cat.NewTransaction(Image, "Watermark")

	defer func() {
		this.Logo.DestoryWand()
		tran.SetStatus(err)
		tran.Complete()
	}()
	this.Logo.CreateWand()
	if this.Location == 0 {
		this.Location = 9
	}
	if this.Location < 1 || this.Location > 9 {
		err = errors.New("Logo location(" + string(this.Location) + ") isn't right!")
		return err
	}
	var x, y int64
	x, y, err = getLocation(this.Location, img, this.Logo)
	if err != nil {
		return err
	}

	if this.Dissolve > 0 && this.Dissolve < 100 {
		this.Logo.Dissolve(this.Dissolve)
	}

	err = img.Composite(this.Logo, x, y)
	return err
}
Example #5
0
func (p *ScaleProcessor) Process(img *img4g.Image) error {
	l4g.Debug("process scale")
	var err error
	tran := cat.Instance().NewTransaction(Image, "Scale")
	defer func() {
		tran.SetStatus(err)
		tran.Complete()
	}()
	err = img.Resize(p.Width, p.Height)
	return err
}
Example #6
0
func (this *QualityProcessor) Process(img *img4g.Image) error {
	l4g.Debug("process quality")
	var err error
	tran := this.Cat.NewTransaction(Image, "Quality")
	defer func() {
		tran.SetStatus(err)
		tran.Complete()
	}()
	err = img.SetCompressionQuality(this.Quality)
	return err
}
Example #7
0
func (this *StripProcessor) Process(img *img4g.Image) error {
	l4g.Debug("process strip")
	var err error
	tran := this.Cat.NewTransaction(Image, "Strip")
	defer func() {
		tran.SetStatus(err)
		tran.Complete()
	}()
	err = img.Strip()
	return err
}
Example #8
0
func (this *FormatProcessor) Process(img *img4g.Image) error {
	l4g.Debug("process format")
	var err error
	tran := this.Cat.NewTransaction(Image, "Format")
	defer func() {
		tran.SetStatus(err)
		tran.Complete()
	}()
	err = img.SetFormat(this.Format)
	return err
}
Example #9
0
func (this *RotateProcessor) Process(img *img4g.Image) error {
	l4g.Debug("process rotate ")
	var err error
	tran := this.Cat.NewTransaction(Image, "Rotate")
	defer func() {
		tran.SetStatus(err)
		tran.Complete()
	}()
	err = img.Rotate(this.Degress)
	return err
}
Example #10
0
func (this *ResizeRProcessor) Process(img *img4g.Image) error {
	log.Debug("process resize r")
	var err error
	tran := this.Cat.NewTransaction("Command", "ResizeR")
	defer func() {
		tran.SetStatus(err)
		tran.Complete()
	}()
	var width, height int64
	width, height, err = img.Size()
	if err != nil {
		return err
	}
	if width <= this.Width && height <= this.Height {
		return nil
	}
	var (
		x int64 = 0
		y int64 = 0
		w int64 = width
		h int64 = height
	)
	if width > this.Width && height > this.Height {
		p1 := float64(this.Width) / float64(this.Height)
		p2 := float64(width) / float64(height)
		w = 0
		h = 0
		if math.Abs(p1-p2) > 0.0001 {
			if p2 > p1 { //以高缩小
				h = height
				w = int64(math.Floor(float64(h) * p1))
				x = (width - w) / 2
			}
			if p2 < p1 { //以宽缩小
				w = width
				h = int64(math.Floor(float64(w) / p1))
				y = (height - h) / 2
			}
			err = img.Crop(w, h, x, y)
			if err != nil {
				return err
			}
		}
		err = img.Resize(this.Width, this.Height)
		return err
	} else {
		if width > this.Width {
			x = (w - this.Width) / 2
			w = this.Width
		}
		if height > this.Height {
			y = (h - this.Height) / 2
			h = this.Height
		}
		err = img.Crop(w, h, x, y)
		return err
	}

}
func (this *DigitalWatermarkProcessor) Process(img *img4g.Image) error {
	log.Debug("process digitalwatermark")
	var err error = nil

	format, err := img.GetFormat()
	if err != nil {
		return err
	}
	if strings.ToLower(format) != "jpg" && strings.ToLower(format) != "jpeg" {
		info := make(map[string]string)
		info["format"] = format
		logEvent(this.Cat, "DigitalWatermarkRefuse", "NotSupportFormat", info)
		return nil
	}

	width, err := img.GetWidth()
	if err != nil {
		return err
	}
	if width < 256 {
		info := make(map[string]string)
		info["width"] = strconv.Itoa(int(width))
		logEvent(this.Cat, "DigitalWatermarkRefuse", "NotSupportSize", info)
		return nil
	}

	height, err := img.GetHeight()
	if err != nil {
		return err
	}
	if height < 256 {
		info := make(map[string]string)
		info["height"] = strconv.Itoa(int(height))
		logEvent(this.Cat, "DigitalWatermarkRefuse", "NotSupportSize", info)
		return nil
	}

	upr := ((int(math.Min(float64(width), float64(height))) / 100.0) + 1) * 100
	tran := this.Cat.NewTransaction("DigitalWatermark", "Min(width, height)<"+strconv.Itoa(int(upr)))
	tran.AddData("size", "width: "+strconv.Itoa(int(width))+"height: "+strconv.Itoa(int(height)))
	defer func() {
		this.Copyright.DestoryWand()
		tran.SetStatus(err)
		tran.Complete()
	}()
	if err = this.Copyright.CreateWand(); err != nil {
		return err
	}
	err = img.DigitalWatermark(this.Copyright)

	return err
}
Example #12
0
//高固定,宽(原图比例计算),宽固定,高(原图比例计算) (压缩)
func (this *ResizeWProcessor) Process(img *img4g.Image) error {
	l4g.Debug("process resize w")
	var err error
	tran := this.Cat.NewTransaction(Image, "ResizeW")
	defer func() {
		tran.SetStatus(err)
		tran.Complete()
	}()
	var width, height int64
	width, height, err = img.Size()
	if err != nil {
		return err
	}
	if width <= this.Width && height <= this.Height {
		return nil
	}
	z := ResizeZProcessor{this.Width, this.Height, this.Cat, width, height}
	err = z.Process(img)
	return err
}
Example #13
0
func (this *ResizeRProcessor) Process(img *img4g.Image) error {
	l4g.Debug("process resize r")
	var err error
	tran := this.Cat.NewTransaction(Image, "ResizeR")
	defer func() {
		tran.SetStatus(err)
		tran.Complete()
	}()
	var width, height int64
	width, height, err = img.Size()
	if err != nil {
		return err
	}
	if width <= this.Width && height <= this.Height {
		return nil
	}
	if width > this.Width && height > this.Height {
		c := ResizeCProcessor{this.Width, this.Height, this.Cat, width, height}
		err = c.Process(img)
		return err
	}
	var (
		x int64 = 0
		y int64 = 0
		w int64 = width
		h int64 = height
	)
	if width > this.Width {
		x = (w - this.Width) / 2
		w = this.Width
	}
	if height > this.Height {
		y = (h - this.Height) / 2
		h = this.Height
	}
	err = img.Crop(w, h, x, y)
	return err
}
Example #14
0
//高固定,宽(原图比例计算),宽固定,高(原图比例计算) (压缩)
func (this *ResizeWProcessor) Process(img *img4g.Image) error {
	log.Debug("process resize w")
	var err error
	tran := this.Cat.NewTransaction("Command", "ResizeW")
	defer func() {
		tran.SetStatus(err)
		tran.Complete()
	}()
	var width, height int64
	width, height, err = img.Size()
	if err != nil {
		return err
	}

	if (width <= this.Width && height <= this.Height && this.Width != 0 && this.Height != 0) || (this.Width == 0 && height <= this.Height) || (this.Height == 0 && width <= this.Width) {
		return nil
	}

	w, h := this.Width, this.Height
	if w == 0 {
		w = width * h / height
		err = img.Resize(w, h)
		return err
	}
	if h == 0 {
		h = height * w / width
		err = img.Resize(w, h)
		return err
	}

	p1 := float64(this.Width) / float64(this.Height)
	p2 := float64(width) / float64(height)

	if p2 > p1 {
		h = int64(math.Floor(float64(this.Width) / p2))
		if int64(math.Abs(float64(h-this.Height))) < 3 {
			h = this.Height
		}
	} else {
		w = int64(math.Floor(float64(this.Height) * p2))
		if int64(math.Abs(float64(w-this.Width))) < 3 {
			w = this.Width
		}
	}
	err = img.Resize(w, h)
	return err
}
Example #15
0
//高固定,宽(原图比例计算),宽固定,高(原图比例计算) (压缩)
func (this *ResizeZProcessor) Process(img *img4g.Image) error {
	l4g.Debug("process resize z")
	var err error
	tran := this.Cat.NewTransaction(Image, "ResizeW")
	defer func() {
		tran.SetStatus(err)
		tran.Complete()
	}()

	var width, height = this.imgWidth, this.imgHeight
	if this.imgWidth == 0 || this.imgHeight == 0 {
		var wd, ht int64
		wd, ht, err = img.Size()
		if err != nil {
			return err
		}
		width = wd
		height = ht
	}
	p1 := float64(this.Width) / float64(this.Height)
	p2 := float64(width) / float64(height)
	w, h := this.Width, this.Height
	if p2 > p1 {
		h = int64(math.Floor(float64(this.Width) / p2))
		if int64(math.Abs(float64(h-this.Height))) < 3 {
			h = this.Height
		}
	} else {
		w = int64(math.Floor(float64(this.Height) * p2))
		if int64(math.Abs(float64(w-this.Width))) < 3 {
			w = this.Width
		}
	}
	err = img.Resize(w, h)
	return err
}
Example #16
0
func (this *ResizeCProcessor) Process(img *img4g.Image) error {
	l4g.Debug("process resize c")
	var err error
	tran := this.Cat.NewTransaction(Image, "ResizeC")
	defer func() {
		tran.SetStatus(err)
		tran.Complete()
	}()

	var width, height = this.imgWidth, this.imgHeight
	var wd, ht int64
	if width == 0 || height == 0 {
		wd, ht, err = img.Size()
		if err != nil {
			return err
		}
		width = wd
		height = ht
	}

	p1 := float64(this.Width) / float64(this.Height)
	p2 := float64(width) / float64(height)
	var (
		x int64 = 0
		y int64 = 0
		w int64 = 0
		h int64 = 0
	)
	if math.Abs(p1-p2) > 0.0001 {
		if p2 > p1 { //以高缩小
			h = height
			w = int64(math.Floor(float64(h) * p1))
			x = (width - w) / 2
		}
		if p2 < p1 { //以宽缩小
			w = width
			h = int64(math.Floor(float64(w) / p1))
			y = (height - h) / 2
		}
		err = img.Crop(w, h, x, y)
		if err != nil {
			return err
		}
	}
	err = img.Resize(this.Width, this.Height)
	return err
}
Example #17
0
func chainProcImg(catinstance cat.Cat, chain *proc.ProcessorChain, img *img4g.Image) (err error) {
	defer func() {
		if r := recover(); r != nil {
			log.WithFields(log.Fields{
				"type": "ProcessImage.Panic",
			}).Error(fmt.Sprintf("%v", r))
			LogErrorEvent(catinstance, "ProcessImage.Panic", fmt.Sprintf("%v", r))
		}
	}()
	defer img.DestoryWand()
	if err = img.CreateWand(); err != nil {
		return
	}
	if err = chain.Process(img); err != nil {
		return
	}
	err = img.WriteImageBlob()
	return
}
Example #18
0
func chainProcImg(chain *proc.ProcessorChain, img *img4g.Image) (err error) {
	defer func() {
		if r := recover(); r != nil {
			err = r.(error)
			log("imagehandler->chainprocimg", r)
		}
	}()
	defer img.DestoryWand()
	if err = img.CreateWand(); err != nil {
		return err
	}
	if err = chain.Process(img); err != nil {
		return err
	}
	if err = img.WriteImageBlob(); err != nil {
		return err
	}
	return nil
}
Example #19
0
func (this *StripProcessor) Process(img *img4g.Image) error {
	log.Debug("process strip")
	err := img.Strip()
	return err
}