preprocessor

type AnalysisOpts ¶

type AnalysisOpts struct {
	UseMergeMap bool
	MergeMap    MergeMap
}

Analysis options.

type AudioDecoder ¶

type AudioDecoder struct{}

AudioDecoder is a converter for the audio file

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

type FileConverter ¶

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

FileConverter is the interface for the file converter

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

type FontLoader ¶

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

FontLoader 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
}

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

type GGPStruct ¶

type GGPStruct struct {
	Sections []struct {
		Cards []struct {
			Element struct {
				Image struct {
					Base64Image string
				}
			}
		}
	}
}

GGPStruct is the layout of a ggp file (which is basically json)

type GgpDecoder ¶

type GgpDecoder struct{}

GgpDecoder is a converter for the geogebra pinboard file

func (j GgpDecoder) Convert(r io.Reader) (interface{}, error)

type GgsDecoder ¶

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

GgsDecoder is a converter for the geogebra slides file

func (g GgsDecoder) Convert(r io.Reader) (interface{}, error)

type GifDecoder ¶

type GifDecoder struct{}

GifDecoder is a converter for the gif file

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

type ImageDecoder ¶

type ImageDecoder struct{}

ImageDecoder is a converter for the image file

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

type LoadedFace ¶

type LoadedFace struct {
	FontFile string
	Face     font.Face
}

LoadedFace 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
}

TxtToImageConverter is a converter for the text file

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