data

type BrimSkirtOptions struct {
	// SkirtCount is the amount of skirt lines around the initial layer.
	SkirtCount int

	// SkirtDistance is the distance between the model (or the most outer brim lines) and the most inner skirt line.
	SkirtDistance Millimeter

	// BrimCount specifies the amount of brim lines around the parts of the initial layer.
	BrimCount int
}

type Face interface {
	Points() [3]MicroVec3
}

type FanSpeedOptions struct {
	LayerToSpeedLUT map[int]int
}

type FilamentOptions struct {
	// FilamentDiameter is the filament diameter used by the printer in micrometer.
	FilamentDiameter Micrometer

	// InitialBedTemperature is the temperature for the heated bed for the first layers.
	InitialBedTemperature int

	// InitialHotendTemperature is the temperature for the hot end for the first layers.
	InitialHotEndTemperature int

	// BedTemperature is the temperature for the heated bed after the first layers.
	BedTemperature int

	// HotEndTemperature is the temperature for the hot end after the first layers.
	HotEndTemperature int

	// InitialTemperatureLayerCount is the number of layers which use the initial temperatures.
	// After this amount of layers, the normal temperatures are used.
	InitialTemperatureLayerCount int

	// RetractionSpeed is the speed used for retraction in mm/s.
	RetractionSpeed Millimeter

	// RetractionLength is the amount to retract in millimeter.
	RetractionLength Millimeter

	// RetractionZHop is the amount to lift head when retracting in millimeter.
	RetractionZHop Millimeter

	// Primary (fan 0) speed, at given layers
	FanSpeed FanSpeedOptions

	// ExtrusionMultiplier is the multiplier in % used to change the amount of filament being extruded.
	ExtrusionMultiplier int
}

type GCodeHunk struct {
	GCodeLines []string
}

type GoSliceOptions struct {
	// PrintVersion indicates if the GoSlice version should be printed.
	PrintVersion bool

	// InputFilePath specifies the path to the input stl file.
	InputFilePath string

	// OutputFilePath specifies the path to the output gcode file.
	OutputFilePath string

	// Logger can be used to redirect the log output to anything you want.
	// All output in GoSlice just calls this logger.
	Logger *log.Logger
}

type Layer interface {
	Polygons() Paths
}

type LayerPart interface {
	Outline() Path
	Holes() Paths

	// Attributes can be any additional data, referenced by a key.
	// Note that you have to know what type the attribute has to
	// use proper type assertion.
	//
	// If the implementation does not support attributes, it should return nil.
	// If the implementation supports attributes but doesn't have any, it should return an empty map.
	Attributes() map[string]interface{}
}

type MicroPoint interface {
	X() Micrometer
	Y() Micrometer

	SetX(x Micrometer)
	SetY(y Micrometer)

	// Add returns a new vector which is the sum of the vectors. (this + vec)
	//
	// By convention it should never mutate the instance and instead return a new copy.
	Add(vec MicroPoint) MicroPoint

	// Sub returns a new vector which is the difference of the vectors. (this - vec)
	//
	// By convention it should never mutate the instance and instead return a new copy.
	Sub(vec MicroPoint) MicroPoint

	// Mul returns a new vector which is the multiplication by the given value. (this * value)
	//
	// By convention it should never mutate the instance and instead return a new copy.
	Mul(value Micrometer) MicroPoint

	// Div returns a new vector which is the division by the given value. (this / value)
	//
	// By convention it should never mutate the instance and instead return a new copy.
	Div(value Micrometer) MicroPoint

	// Rotate returns a new vector which is rotated around (0|0) by the given degree value.
	//
	// By convention it should never mutate the instance and instead return a new copy.
	Rotate(degree float64) MicroPoint

	// ShorterThanOrEqual checks if the length of the vector fits inside the given length.
	// Returns true if the vector length is <= the given length.
	ShorterThanOrEqual(length Micrometer) bool

	// Size2 returns the length of the vector^2.
	//
	// Use this whenever possible as it may be faster than Size().
	Size2() Micrometer

	// Size2 returns the length of the vector.
	//
	// Use Size2() whenever possible as it may be faster than Size().
	Size() Micrometer

	// SizeMM returns the length of the vector in mm.
	SizeMM() Millimeter

	// Copy returns a completely new copy of the vector.
	Copy() MicroPoint
}

type MicroVec3 interface {
	X() Micrometer
	Y() Micrometer
	Z() Micrometer

	SetX(x Micrometer)
	SetY(y Micrometer)
	SetZ(z Micrometer)

	// PointXY returns a new point only with the x and y coordinates of the vector.
	PointXY() MicroPoint

	// Add returns a new vector which is the sum of the vectors. (this + vec)
	//
	// By convention it should never mutate the instance and instead return a new copy.
	Add(vec MicroVec3) MicroVec3

	// Sub returns a new vector which is the difference of the vectors. (this - vec)
	//
	// By convention it should never mutate the instance and instead return a new copy.
	Sub(vec MicroVec3) MicroVec3

	// Mul returns a new vector which is the multiplication by the given value. (this * value)
	//
	// By convention it should never mutate the instance and instead return a new copy.
	Mul(value Micrometer) MicroVec3

	// Div returns a new vector which is the division by the given value. (this / value)
	//
	// By convention it should never mutate the instance and instead return a new copy.
	Div(value Micrometer) MicroVec3

	Max() Micrometer

	// ShorterThanOrEqual checks if the length of the vector fits inside the given length.
	// Returns true if the vector length is <= the given length.
	ShorterThanOrEqual(length Micrometer) bool

	// Size2 returns the length of the vector^2.
	//
	// Use this whenever possible as it may be faster than Size().
	Size2() Micrometer

	// Size2 returns the length of the vector.
	//
	// Use Size2() this whenever possible as it may be faster than Size().
	Size() Micrometer

	// Copy returns a completely new copy of the vector.
	Copy() MicroVec3

	// String implements the value interface needed for the options.
	String() string
	// Set implements the value interface needed for the options.
	Set(s string) error
	// Type implements the value interface needed for the options.
	Type() string
}

type Micrometer int64

type Millimeter float32

type Model interface {
	FaceCount() int
	Face(index int) Face
	Min() MicroVec3
	Max() MicroVec3
}

type OptimizedFace interface {
	Face
	TouchingFaceIndices() [3]int
	MinZ() Micrometer
	MaxZ() Micrometer
}

type OptimizedModel interface {
	Model

	// Bounds returns the amount of faces.
	Size() MicroVec3

	OptimizedFace(index int) OptimizedFace
	SaveDebugSTL(filename string) error
}

type Options struct {
	Slicing  SlicingOptions
	Printer  PrinterOptions
	Filament FilamentOptions
	Print    PrintOptions
	GoSlice  GoSliceOptions
}

type PartitionedLayer interface {
	LayerParts() []LayerPart

	// Attributes can be any additional data, referenced by a key.
	// Note that you have to know what type the attribute has to
	// use proper type assertion.
	//
	// If the implementation does not support attributes, it should return nil.
	// If the implementation supports attributes but doesn't have ane, it should return an empty map.
	Attributes() map[string]interface{}

	// Bounds returns the min and max Points which specify the bounding box.
	Bounds() (MicroPoint, MicroPoint)
}

type Path []MicroPoint

type Paths []Path

type PrintOptions struct {
	// InitialLayerSpeed is the speed only for the first layer in mm per second.
	IntialLayerSpeed Millimeter

	// LayerSpeed is the speed for all but the first layer in mm per second.
	LayerSpeed Millimeter

	// OuterPerimeterSpeed is the speed only for outer perimeters in mm per second.
	OuterPerimeterSpeed Millimeter

	// MoveSpeed is the speed for all non printing moves in mm per second.
	MoveSpeed Millimeter

	// InitialLayerThickness is the layer thickness for the first layer.
	InitialLayerThickness Micrometer

	// LayerThickness is the thickness for all but the first layer.
	LayerThickness Micrometer

	// InsetCount is the number of perimeters.
	InsetCount int

	// InfillOverlapPercent is the percentage of overlap into the perimeters.
	InfillOverlapPercent int

	// AdditionalInternalInfillOverlapPercent is the percentage used to make the internal
	// infill (infill not blocked by the perimeters) even bigger so that it grows a bit into the model.
	AdditionalInternalInfillOverlapPercent int

	// InfillPercent is the amount of infill which should be generated.
	InfillPercent int

	// InfillRotationDegree is the rotation used for the infill.
	InfillRotationDegree int

	// InfillZigZig sets if the infill should use connected lines in zig zag form.
	InfillZigZag bool

	// NumberBottomLayers is the amount of layers the bottom layers should grow into the model.
	NumberBottomLayers int

	// NumberBottomLayers is the amount of layers the bottom layers should grow into the model.
	NumberTopLayers int

	Support SupportOptions

	BrimSkirt BrimSkirtOptions
}

type PrinterOptions struct {
	// ExtrusionWidth is the diameter of your nozzle.
	ExtrusionWidth Micrometer

	// Center is the point where the model is finally placed.
	Center MicroVec3

	// ForceSafeStartStopGCode toggles enforcing setting temps at beginning/end of print.
	ForceSafeStartStopGCode bool

	// HasHeatedBed toggles whether to add bed temperature settings to gcode.
	HasHeatedBed bool

	// StartGCode contains an array of strings to prepend the generated gcode.
	StartGCode GCodeHunk

	// EndGCode contains an array of strings to postpend the genreated gcode.
	EndGCode GCodeHunk
}

type SlicingOptions struct {
	// MeldDistance is the distance which two points have to be
	// within to count them as one point.
	MeldDistance Micrometer

	// JoinPolygonSnapDistance is the distance used to check if two open
	// polygons can be snapped together to one bigger polygon.
	// Checked by the start and endpoints of the polygons.
	JoinPolygonSnapDistance Micrometer

	// FinishPolygonSnapDistance is the max distance between start end endpoint of
	// a polygon used to check if a open polygon can be closed.
	FinishPolygonSnapDistance Micrometer
}

type SupportOptions struct {
	// Enabled enables the generation of support structures.
	Enabled bool

	// ThresholdAngle is the angle up to which no support is generated.
	ThresholdAngle int

	// TopGapLayers is the amount of layers without support.
	TopGapLayers int

	// InterfaceLayers is the amount of layers which are filled differently as interface to the object.
	InterfaceLayers int

	// PatternSpacing is the spacing used to create the support pattern.
	PatternSpacing Millimeter

	// Gap is the gap between the model and the support.
	Gap Millimeter
}