raster

package
v0.0.0-...-44be3dc Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 4, 2015 License: Freetype Imports: 6 Imported by: 0

Documentation

Overview

The raster package provides an anti-aliasing 2-D rasterizer.

It is part of the larger Freetype-Go suite of font-related packages, but the raster package is not specific to font rasterization, and can be used standalone without any other Freetype-Go package.

Rasterization is done by the same area/coverage accumulation algorithm as the Freetype "smooth" module, and the Anti-Grain Geometry library. A description of the area/coverage algorithm is at http://projects.tuxee.net/cl-vectors/section-the-cl-aa-algorithm

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Stroke 

func Stroke(p Adder, q Path, width Fix32, cr Capper, jr Joiner)

Stroke adds q stroked with the given width to p. The result is typically self-intersecting and should be rasterized with UseNonZeroWinding. cr and jr may be nil, which defaults to a RoundCapper or RoundJoiner.

Types

type Adder 

type Adder interface {
	// Start starts a new curve at the given point.
	Start(a Point)
	// Add1 adds a linear segment to the current curve.
	Add1(b Point)
	// Add2 adds a quadratic segment to the current curve.
	Add2(b, c Point)
	// Add3 adds a cubic segment to the current curve.
	Add3(b, c, d Point)
}

An Adder accumulates points on a curve.

type AlphaOverPainter 

type AlphaOverPainter struct {
	Image *image.Alpha
}

An AlphaOverPainter is a Painter that paints Spans onto an image.Alpha using the Over Porter-Duff composition operator.

func NewAlphaOverPainter 

func NewAlphaOverPainter(m *image.Alpha) AlphaOverPainter

NewAlphaOverPainter creates a new AlphaOverPainter for the given image.

func (AlphaOverPainter) Paint 

func (r AlphaOverPainter) Paint(ss []Span, done bool)

Paint satisfies the Painter interface by painting ss onto an image.Alpha.

type AlphaSrcPainter 

type AlphaSrcPainter struct {
	Image *image.Alpha
}

An AlphaSrcPainter is a Painter that paints Spans onto an image.Alpha using the Src Porter-Duff composition operator.

func NewAlphaSrcPainter 

func NewAlphaSrcPainter(m *image.Alpha) AlphaSrcPainter

NewAlphaSrcPainter creates a new AlphaSrcPainter for the given image.

func (AlphaSrcPainter) Paint 

func (r AlphaSrcPainter) Paint(ss []Span, done bool)

Paint satisfies the Painter interface by painting ss onto an image.Alpha.

type Capper 

type Capper interface {
	// Cap adds a cap to p given a pivot point and the normal vector of a
	// terminal segment. The normal's length is half of the stroke width.
	Cap(p Adder, halfWidth Fix32, pivot, n1 Point)
}

A Capper signifies how to begin or end a stroked path. 

var ButtCapper Capper = CapperFunc(buttCapper)

ButtCapper adds butt caps to a stroked path. 

var RoundCapper Capper = CapperFunc(roundCapper)

RoundCapper adds round caps to a stroked path. 

var SquareCapper Capper = CapperFunc(squareCapper)

SquareCapper adds square caps to a stroked path.

type CapperFunc 

type CapperFunc func(Adder, Fix32, Point, Point)

The CapperFunc type adapts an ordinary function to be a Capper.

func (CapperFunc) Cap 

func (f CapperFunc) Cap(p Adder, halfWidth Fix32, pivot, n1 Point)

type Fix32 

type Fix32 int32

A Fix32 is a 24.8 fixed point number.

func (Fix32) String 

func (x Fix32) String() string

String returns a human-readable representation of a 24.8 fixed point number. For example, the number one-and-a-quarter becomes "1:064".

type Fix64 

type Fix64 int64

A Fix64 is a 48.16 fixed point number.

func (Fix64) String 

func (x Fix64) String() string

String returns a human-readable representation of a 48.16 fixed point number. For example, the number one-and-a-quarter becomes "1:16384".

type GammaCorrectionPainter 

type GammaCorrectionPainter struct {
	// The wrapped Painter.
	Painter Painter
	// contains filtered or unexported fields
}

A GammaCorrectionPainter wraps another Painter, performing gamma-correction on each Span's alpha value.

func NewGammaCorrectionPainter 

func NewGammaCorrectionPainter(p Painter, gamma float64) *GammaCorrectionPainter

NewGammaCorrectionPainter creates a new GammaCorrectionPainter that wraps the given Painter.

func (*GammaCorrectionPainter) Paint 

func (g *GammaCorrectionPainter) Paint(ss []Span, done bool)

Paint delegates to the wrapped Painter after performing gamma-correction on each Span.

func (*GammaCorrectionPainter) SetGamma 

func (g *GammaCorrectionPainter) SetGamma(gamma float64)

SetGamma sets the gamma value.

type Joiner 

type Joiner interface {
	// Join adds a join to the two sides of a stroked path given a pivot
	// point and the normal vectors of the trailing and leading segments.
	// Both normals have length equal to half of the stroke width.
	Join(lhs, rhs Adder, halfWidth Fix32, pivot, n0, n1 Point)
}

A Joiner signifies how to join interior nodes of a stroked path. 

var BevelJoiner Joiner = JoinerFunc(bevelJoiner)

BevelJoiner adds bevel joins to a stroked path. 

var RoundJoiner Joiner = JoinerFunc(roundJoiner)

RoundJoiner adds round joins to a stroked path.

type JoinerFunc 

type JoinerFunc func(lhs, rhs Adder, halfWidth Fix32, pivot, n0, n1 Point)

The JoinerFunc type adapts an ordinary function to be a Joiner.

func (JoinerFunc) Join 

func (f JoinerFunc) Join(lhs, rhs Adder, halfWidth Fix32, pivot, n0, n1 Point)

type MonochromePainter 

type MonochromePainter struct {
	Painter Painter
	// contains filtered or unexported fields
}

A MonochromePainter wraps another Painter, quantizing each Span's alpha to be either fully opaque or fully transparent.

func NewMonochromePainter 

func NewMonochromePainter(p Painter) *MonochromePainter

NewMonochromePainter creates a new MonochromePainter that wraps the given Painter.

func (*MonochromePainter) Paint 

func (m *MonochromePainter) Paint(ss []Span, done bool)

Paint delegates to the wrapped Painter after quantizing each Span's alpha value and merging adjacent fully opaque Spans.

type Painter 

type Painter interface {
	Paint(ss []Span, done bool)
}

A Painter knows how to paint a batch of Spans. Rasterization may involve Painting multiple batches, and done will be true for the final batch. The Spans' Y values are monotonically increasing during a rasterization. Paint may use all of ss as scratch space during the call.

type PainterFunc 

type PainterFunc func(ss []Span, done bool)

The PainterFunc type adapts an ordinary function to the Painter interface.

func (PainterFunc) Paint 

func (f PainterFunc) Paint(ss []Span, done bool)

Paint just delegates the call to f.

type Path 

type Path []Fix32

A Path is a sequence of curves, and a curve is a start point followed by a sequence of linear, quadratic or cubic segments.

func (*Path) Add1 

func (p *Path) Add1(b Point)

Add1 adds a linear segment to the current curve.

func (*Path) Add2 

func (p *Path) Add2(b, c Point)

Add2 adds a quadratic segment to the current curve.

func (*Path) Add3 

func (p *Path) Add3(b, c, d Point)

Add3 adds a cubic segment to the current curve.

func (*Path) AddPath 

func (p *Path) AddPath(q Path)

AddPath adds the Path q to p.

func (*Path) AddStroke 

func (p *Path) AddStroke(q Path, width Fix32, cr Capper, jr Joiner)

AddStroke adds a stroked Path.

func (*Path) Clear 

func (p *Path) Clear()

Clear cancels any previous calls to p.Start or p.AddXxx.

func (*Path) Start 

func (p *Path) Start(a Point)

Start starts a new curve at the given point.

func (Path) String 

func (p Path) String() string

String returns a human-readable representation of a Path.

type Point 

type Point struct {
	X, Y Fix32
}

A Point represents a two-dimensional point or vector, in 24.8 fixed point format.

func (Point) Add 

func (p Point) Add(q Point) Point

Add returns the vector p + q.

func (Point) Dot 

func (p Point) Dot(q Point) Fix64

Dot returns the dot product p·q.

func (Point) Len 

func (p Point) Len() Fix32

Len returns the length of the vector p.

func (Point) Mul 

func (p Point) Mul(k Fix32) Point

Mul returns the vector k * p.

func (Point) Neg 

func (p Point) Neg() Point

Neg returns the vector -p, or equivalently p rotated by 180 degrees.

func (Point) Norm 

func (p Point) Norm(length Fix32) Point

Norm returns the vector p normalized to the given length, or the zero Point if p is degenerate.

func (Point) Rot135CCW 

func (p Point) Rot135CCW() Point

Rot135CCW returns the vector p rotated counter-clockwise by 135 degrees. Note that the Y-axis grows downwards, so {1, 0}.Rot135CCW is {-1/√2, -1/√2}.

func (Point) Rot135CW 

func (p Point) Rot135CW() Point

Rot135CW returns the vector p rotated clockwise by 135 degrees. Note that the Y-axis grows downwards, so {1, 0}.Rot135CW is {-1/√2, 1/√2}.

func (Point) Rot45CCW 

func (p Point) Rot45CCW() Point

Rot45CCW returns the vector p rotated counter-clockwise by 45 degrees. Note that the Y-axis grows downwards, so {1, 0}.Rot45CCW is {1/√2, -1/√2}.

func (Point) Rot45CW 

func (p Point) Rot45CW() Point

Rot45CW returns the vector p rotated clockwise by 45 degrees. Note that the Y-axis grows downwards, so {1, 0}.Rot45CW is {1/√2, 1/√2}.

func (Point) Rot90CCW 

func (p Point) Rot90CCW() Point

Rot90CCW returns the vector p rotated counter-clockwise by 90 degrees. Note that the Y-axis grows downwards, so {1, 0}.Rot90CCW is {0, -1}.

func (Point) Rot90CW 

func (p Point) Rot90CW() Point

Rot90CW returns the vector p rotated clockwise by 90 degrees. Note that the Y-axis grows downwards, so {1, 0}.Rot90CW is {0, 1}.

func (Point) String 

func (p Point) String() string

String returns a human-readable representation of a Point.

func (Point) Sub 

func (p Point) Sub(q Point) Point

Sub returns the vector p - q.

type RGBAPainter 

type RGBAPainter struct {
	// The image to compose onto.
	Image *image.RGBA
	// The Porter-Duff composition operator.
	Op draw.Op
	// contains filtered or unexported fields
}

func NewRGBAPainter 

func NewRGBAPainter(m *image.RGBA) *RGBAPainter

NewRGBAPainter creates a new RGBAPainter for the given image.

func (*RGBAPainter) Paint 

func (r *RGBAPainter) Paint(ss []Span, done bool)

Paint satisfies the Painter interface by painting ss onto an image.RGBA.

func (*RGBAPainter) SetColor 

func (r *RGBAPainter) SetColor(c color.Color)

SetColor sets the color to paint the spans.

type Rasterizer 

type Rasterizer struct {
	// If false, the default behavior is to use the even-odd winding fill
	// rule during Rasterize.
	UseNonZeroWinding bool
	// An offset (in pixels) to the painted spans.
	Dx, Dy int
	// contains filtered or unexported fields
}

func NewRasterizer 

func NewRasterizer(width, height int) *Rasterizer

NewRasterizer creates a new Rasterizer with the given bounds.

func (*Rasterizer) Add1 

func (r *Rasterizer) Add1(b Point)

Add1 adds a linear segment to the current curve.

func (*Rasterizer) Add2 

func (r *Rasterizer) Add2(b, c Point)

Add2 adds a quadratic segment to the current curve.

func (*Rasterizer) Add3 

func (r *Rasterizer) Add3(b, c, d Point)

Add3 adds a cubic segment to the current curve.

func (*Rasterizer) AddPath 

func (r *Rasterizer) AddPath(p Path)

AddPath adds the given Path.

func (*Rasterizer) AddStroke 

func (r *Rasterizer) AddStroke(q Path, width Fix32, cr Capper, jr Joiner)

AddStroke adds a stroked Path.

func (*Rasterizer) Clear 

func (r *Rasterizer) Clear()

Clear cancels any previous calls to r.Start or r.AddXxx.

func (*Rasterizer) Rasterize 

func (r *Rasterizer) Rasterize(p Painter)

Rasterize converts r's accumulated curves into Spans for p. The Spans passed to p are non-overlapping, and sorted by Y and then X. They all have non-zero width (and 0 <= X0 < X1 <= r.width) and non-zero A, except for the final Span, which has Y, X0, X1 and A all equal to zero.

func (*Rasterizer) SetBounds 

func (r *Rasterizer) SetBounds(width, height int)

SetBounds sets the maximum width and height of the rasterized image and calls Clear. The width and height are in pixels, not Fix32 units.

func (*Rasterizer) Start 

func (r *Rasterizer) Start(a Point)

Start starts a new curve at the given point.

type Span 

type Span struct {
	Y, X0, X1 int
	A         uint32
}

A Span is a horizontal segment of pixels with constant alpha. X0 is an inclusive bound and X1 is exclusive, the same as for slices. A fully opaque Span has A == 1<<32 - 1.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.