preprocessor

type AnalysisOpts ¶

type AnalysisOpts struct {
	UseMergeMap bool
	MergeMap    MergeMap
}

Analysis options.

type FileConverter ¶

type FileConverter interface {
	Convert(r io.Reader) (interface{}, error)
}

func ForType(mimeType string, opts map[string]interface{}) FileConverter

type FontLoader ¶

type FontLoader struct {
	// contains filtered or unexported fields
}

Represents a FontLoader. Use the "NewFontLoader" to get a instance

func NewFontLoader(fontMapFile string, faceOpts *opentype.FaceOptions) (*FontLoader, error)

{
	"fontMap": {
		"Han": "packaged/myFont-CJK.otf",
		"Arabic": "packaged/myFont-Arab.otf",
		"Latin": "/fonts/regular/myFont.otf"
	}
	"defaultFont": "/fonts/regular/myFont.otf"
}

func (fl *FontLoader) GetFaceOptDPI() float64

func (fl *FontLoader) GetFaceOptSize() float64

func (fl *FontLoader) GetScriptList() []string

func (fl *FontLoader) LoadFaceForScript(script string) (*LoadedFace, error)

type FontMap ¶

type FontMap struct {
	FontMap     map[string]string `json:"fontMap"`
	DefaultFont string            `json:"defaultFont"`
}

FontMap maps a script with the target font to be used for that script It also uses a DefaultFont in case there isn't a matching script in the map

For cases like Japanese where multiple scripts are used, we rely on the text analyzer to use the script which is unique to japanese (Hiragana or Katakana) even if it has to overwrite the "official" detected script (Han). This means that "Han" should be used just for chinese while "Hiragana" and "Katakana" should be used for japanese

type FontMapData ¶

type FontMapData struct {
	FMap *FontMap
	FLoc string
}

It contains the location of the loaded file (in FLoc) and the FontMap loaded from the file

type GifDecoder ¶

type GifDecoder struct{}

func (i GifDecoder) Convert(r io.Reader) (interface{}, error)

type ImageDecoder ¶

type ImageDecoder struct{}

func (i ImageDecoder) Convert(r io.Reader) (interface{}, error)

type LoadedFace ¶

type LoadedFace struct {
	FontFile string
	Face     font.Face
}

It contains the location of the font used, and the loaded face (font.Face) ready to be used

type MergeMap ¶

type MergeMap map[string]map[string]string

Convenient map[string]map[string]string type used to merge multiple scripts into one. This is mainly used for japanese language which uses "Han", "Hiragana" and "Katakana" scripts.

The map contains the expected previous script as first key, the expected current script as second key, and the resulting script (if both keys match) as value

type ScriptRange ¶

type ScriptRange struct {
	Low, High    int
	Spaces       []int
	TargetScript string
	RuneCount    int
}

A script range. The range should be attached to a string which could contain multiple scripts. The "TargetScript" will go from bytes "Low" to "High" (both inclusive), and contains a "RuneCount" number of runes or chars (mostly for debugging purposes). The Space contains the bytes (inside the range) that are considered as white space.

type TextAnalysis ¶

type TextAnalysis struct {
	ScriptRanges []ScriptRange
	RuneCount    map[string]int
	Text         string
}

The result of a text analysis. It contains the analyzed text, a list of script ranges (see the ScriptRange type) and a map containing how many runes have been detected for a particular script.

func (tr *TextAnalysis) MergeCommon(mergeMap MergeMap)

type TextAnalyzer ¶

type TextAnalyzer struct {
	// contains filtered or unexported fields
}

The TextAnalyzer object contains private members. It should be created via "NewTextAnalyzer" function.

func NewTextAnalyzer(scriptList []string) TextAnalyzer

func (ta *TextAnalyzer) AnalyzeString(word string, opts AnalysisOpts) TextAnalysis

type TxtToImageConverter ¶

type TxtToImageConverter struct {
	// contains filtered or unexported fields
}

func (t TxtToImageConverter) Convert(r io.Reader) (interface{}, error)