Merge pull request #30 from gotsunami/text-annotate

Text annotate + canvas.Fit()

Author: Pierre Massat

canvas.go

@@ -62,6 +62,8 @@ type Canvas struct {
 	height   string
 
 	quantumRange uint
+
+	text *TextProperties
 }
 
 func init() {
@@ -346,16 +348,31 @@ func (self *Canvas) Thumbnail(width uint, height uint) error {
 
 	ratio = math.Min(float64(self.Width())/float64(width), float64(self.Height())/float64(height))
 
+	return self.thumbnail(width, height, ratio)
+}
+
+// Creates a thumbnail that fits within the given dimensions
+func (self *Canvas) Fit(width uint, height uint) error {
+
+	var ratio float64
+
+	// Normalizing image.
+
+	ratio = math.Max(float64(self.Width())/float64(width), float64(self.Height())/float64(height))
+
+	return self.thumbnail(width, height, ratio)
+}
+
+func (self *Canvas) thumbnail(width uint, height uint, ratio float64) error {
+
 	if ratio < 1.0 {
 		// Origin image is smaller than the thumbnail image.
-		max := uint(math.Max(float64(width), float64(height)))
-
 		// Empty replacement buffer with transparent background.
 		replacement := New()
 
 		replacement.SetBackgroundColor("none")
 
-		replacement.Blank(max, max)
+		replacement.Blank(width, height)
 
 		// Putting original image in the center of the replacement canvas.
 		replacement.AppendCanvas(self, int(int(width-self.Width())/2), int(int(height-self.Height())/2))
@@ -539,16 +556,14 @@ func (self *Canvas) Quality() uint {
 	return uint(C.MagickGetImageCompressionQuality(self.wand))
 }
 
-/*
 // Sets canvas's foreground color.
-func (self *Canvas) SetColor(color string) (bool) {
-  status := C.PixelSetColor(self.fg, C.CString(color))
-  if status == C.MagickFalse {
-    return false
-  }
-  return true
+func (self *Canvas) SetColor(color string) bool {
+	status := C.PixelSetColor(self.fg, C.CString(color))
+	if status == C.MagickFalse {
+		return false
+	}
+	return true
 }
-*/
 
 // Sets canvas' background color.
 func (self *Canvas) SetBackgroundColor(color string) error {
@@ -773,6 +788,11 @@ func (self *Canvas) Destroy() error {
 		self.wand = nil
 	}
 
+	if self.text != nil && self.text.UnderColor != nil {
+		C.DestroyPixelWand(self.text.UnderColor)
+		self.text.UnderColor = nil
+	}
+
 	return nil
 }
 
@@ -998,21 +1018,6 @@ func (self *Canvas) QuantumRange() uint {
 	return self.quantumRange
 }
 
-func (self *Canvas) SetFontFamily(name string) error {
-	family := C.CString(name)
-	defer C.free(unsafe.Pointer(family))
-
-	if C.MagickSetFont(self.wand, family) == C.MagickFalse {
-		return fmt.Errorf("Could not set font family: %s", self.Error())
-	}
-
-	return nil
-}
-
-func (self *Canvas) SetFontSize(size float64) {
-	C.MagickSetPointsize(self.wand, C.double(size))
-}
-
 func (self *Canvas) SetGravity(gravity uint) {
 	C.MagickSetGravity(self.wand, C.GravityType(gravity))
 }
@@ -1045,5 +1050,7 @@ func New() *Canvas {
 
 	self.SetFillColor("#888888")
 
+	self.text = self.NewTextProperties(true)
+
 	return self
 }

canvas_test.go

@@ -103,6 +103,23 @@ func TestThumbnail(t *testing.T) {
 	canvas.Destroy()
 }
 
+func TestFit(t *testing.T) {
+	canvas := New()
+
+	err := canvas.Open("_examples/input/example.png")
+
+	if err == nil {
+		canvas.AutoOrientate()
+
+		canvas.Fit(100, 100)
+		
+		canvas.Write("_examples/output/example-fit.png")
+	} else {
+		t.Errorf("Error: %s\n", err)
+	}
+
+	canvas.Destroy()
+}
 // https://github.com/gosexy/canvas/issues/3
 func TestThumbnailIssue3(t *testing.T) {
 	canvas := New()

text.go

@@ -0,0 +1,228 @@
+/* text.go contains functions for text annotation
+TODO:
+getters and setters for
+- Stretch (redefine C type)
+- Style (redefine C type)
+- Resolution (two doubles)
+- Decoration (redefine C type)
+- Encoding (string)
+-  DrawSetTextInterlineSpacing(DrawingWand *,const double),
+-  DrawSetTextInterwordSpacing(DrawingWand *,const double),
+-  DrawSetGravity(DrawingWand *wand,const GravityType gravity)
+*/
+
+package canvas
+
+/*
+#cgo CFLAGS: -fopenmp -I./_include
+#cgo LDFLAGS: -lMagickWand -lMagickCore
+
+#include <wand/magick_wand.h>
+*/
+import "C"
+
+import (
+	"unsafe"
+)
+
+type Alignment uint
+
+const (
+	UndefinedAlign Alignment = Alignment(C.UndefinedAlign)
+	LeftAlign                = Alignment(C.LeftAlign)
+	CenterAlign              = Alignment(C.CenterAlign)
+	RightAlign               = Alignment(C.RightAlign)
+)
+
+// structure containing all text properties for an annotation
+// except the colors that are defined by FillColor and StrokeColor
+type TextProperties struct {
+	Font   string
+	Family string
+	Size   float64
+	// Stretch		C.StretchType
+	Weight uint
+	// Style		C.StyleType
+	// Resolution  [2]C.double
+	Alignment Alignment
+	Antialias bool
+	// Decoration	C.DecorationType
+	// Encoding	string
+	Kerning float64
+	// Interline	float64
+	// Interword	float64
+	UnderColor *C.PixelWand
+}
+
+// Returns a TextProperties structure.
+// Parameters:
+//   readDefault: if false, returns an empty structure.
+//				  if true, returns a structure set with current canvas settings
+func (self *Canvas) NewTextProperties(readDefault bool) *TextProperties {
+	if readDefault {
+		cfont := C.DrawGetFont(self.drawing)
+		defer C.free(unsafe.Pointer(cfont))
+		cfamily := C.DrawGetFontFamily(self.drawing)
+		defer C.free(unsafe.Pointer(cfamily))
+		csize := C.DrawGetFontSize(self.drawing)
+		cweight := C.DrawGetFontWeight(self.drawing)
+		calignment := C.DrawGetTextAlignment(self.drawing)
+		cantialias := C.DrawGetTextAntialias(self.drawing)
+		ckerning := C.DrawGetTextKerning(self.drawing)
+		antialias := cantialias == C.MagickTrue
+
+		underColor := C.NewPixelWand()
+		C.DrawGetTextUnderColor(self.drawing, underColor)
+		return &TextProperties{
+			Font:       C.GoString(cfont),
+			Family:     C.GoString(cfamily),
+			Size:       float64(csize),
+			Weight:     uint(cweight),
+			Alignment:  Alignment(calignment),
+			Antialias:  antialias,
+			Kerning:    float64(ckerning),
+			UnderColor: underColor,
+		}
+	}
+	return &TextProperties{
+		UnderColor: C.NewPixelWand(),
+	}
+}
+
+// Sets canvas' default TextProperties
+func (self *Canvas) SetTextProperties(def *TextProperties) {
+	if def != nil {
+		self.text = def
+		self.SetFontFamily(def.Family)
+		self.SetFont(def.Font, def.Size)
+		self.SetFontWeight(def.Weight)
+		self.SetTextAlignment(def.Alignment)
+		self.SetTextAntialias(def.Antialias)
+		self.SetTextKerning(def.Kerning)
+	}
+}
+
+// Gets a copy of canvas' current TextProperties
+func (self *Canvas) TextProperties() *TextProperties {
+	if self.text == nil {
+		return nil
+	}
+	cpy := *self.text
+	return &cpy
+}
+
+// Sets canvas' default font name
+func (self *Canvas) SetFontName(font string) {
+	self.text.Font = font
+	cfont := C.CString(font)
+	defer C.free(unsafe.Pointer(cfont))
+	C.DrawSetFont(self.drawing, cfont)
+}
+
+// Returns canvas' current font name
+func (self *Canvas) FontName() string {
+	return self.text.Font
+}
+
+// Sets canvas' default font family
+func (self *Canvas) SetFontFamily(family string) {
+	self.text.Family = family
+	cfamily := C.CString(family)
+	defer C.free(unsafe.Pointer(cfamily))
+	C.DrawSetFontFamily(self.drawing, cfamily)
+}
+
+// Returns canvas' current font family
+func (self *Canvas) FontFamily() string {
+	return self.text.Family
+}
+
+// Sets canvas' default font size
+func (self *Canvas) SetFontSize(size float64) {
+	self.text.Size = size
+	C.DrawSetFontSize(self.drawing, C.double(size))
+}
+
+// Returns canvas' current font size
+func (self *Canvas) FontSize() float64 {
+	return self.text.Size
+}
+
+// Sets canvas' default font weight
+func (self *Canvas) SetFontWeight(weight uint) {
+	self.text.Weight = weight
+	C.DrawSetFontWeight(self.drawing, C.size_t(weight))
+}
+
+// Returns canvas' current font weight
+func (self *Canvas) FontWeight() uint {
+	return self.text.Weight
+}
+
+// Sets canvas' font name and size.
+// If font is 0-length, the current font family is not changed
+// If size is <= 0, the current font size is not changed
+func (self *Canvas) SetFont(font string, size float64) {
+	if len(font) > 0 {
+		self.SetFontName(font)
+	}
+	if size > 0 {
+		self.SetFontSize(size)
+	}
+}
+
+// Returns canvas' current font name and size
+func (self *Canvas) Font() (string, float64) {
+	return self.text.Font, self.text.Size
+}
+
+// Sets canvas' default text alignment. Available values are:
+// UndefinedAlign (?), LeftAlign, CenterAlign, RightAlign
+func (self *Canvas) SetTextAlignment(a Alignment) {
+	self.text.Alignment = a
+	C.DrawSetTextAlignment(self.drawing, C.AlignType(a))
+}
+
+// Returns the canvas' current text aligment
+func (self *Canvas) TextAlignment() Alignment {
+	return self.text.Alignment
+}
+
+// Sets canvas' default text antialiasing option.
+func (self *Canvas) SetTextAntialias(b bool) {
+	self.text.Antialias = b
+	C.DrawSetTextAntialias(self.drawing, magickBoolean(b))
+}
+
+// Returns the canvas' current text aligment
+func (self *Canvas) TextAntialias() bool {
+	return self.text.Antialias
+}
+
+// Sets canvas' default text antialiasing option.
+func (self *Canvas) SetTextKerning(k float64) {
+	self.text.Kerning = k
+	C.DrawSetTextKerning(self.drawing, C.double(k))
+}
+
+// Returns the canvas' current text aligment
+func (self *Canvas) TextKerning() float64 {
+	return self.text.Kerning
+}
+
+// Draws a string at the specified coordinates and using the current canvas
+// Alignment.
+func (self *Canvas) Annotate(text string, x, y float64) {
+	c_text := C.CString(text)
+	defer C.free(unsafe.Pointer(c_text))
+	C.DrawAnnotation(self.drawing, C.double(x), C.double(y), (*C.uchar)(unsafe.Pointer(c_text)))
+}
+
+// Draws a string at the specified coordinates and using the specified Text Properties
+// Does not modify the canvas' default TextProperties
+func (self *Canvas) AnnotateWithProperties(text string, x, y float64, prop *TextProperties) {
+	tmp := self.TextProperties()
+	self.SetTextProperties(prop)
+	self.Annotate(text, x, y)
+	self.SetTextProperties(tmp)
+}