From 2aa1f2ed922fd943b7eabf8e4d1c1ac6819b8abf Mon Sep 17 00:00:00 2001 From: aligator Date: Sat, 3 Apr 2021 16:56:23 +0200 Subject: [PATCH] Add some more program output --- data/option.go | 2 ++ gcode/generator.go | 1 + gcode/generator_test.go | 7 ++++++- goslice.go | 7 ++++++- handler/handler.go | 13 +++++++++++++ modifier/brim.go | 4 ++++ modifier/infill.go | 4 ++++ modifier/internal_infill.go | 4 ++++ modifier/perimeter.go | 4 ++++ modifier/support.go | 8 ++++++++ slicer/slicer.go | 1 - 11 files changed, 52 insertions(+), 3 deletions(-) diff --git a/data/option.go b/data/option.go index 73eb075..e023125 100644 --- a/data/option.go +++ b/data/option.go @@ -267,6 +267,8 @@ type GoSliceOptions struct { // 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 } diff --git a/gcode/generator.go b/gcode/generator.go index f673db6..3cc7909 100644 --- a/gcode/generator.go +++ b/gcode/generator.go @@ -65,6 +65,7 @@ func (g *generator) Generate(layers []data.PartitionedLayer) (string, error) { maxLayer := len(layers) - 1 for layerNr := range layers { + g.options.GoSlice.Logger.Printf("Render layer %d/%d\n", layerNr, maxLayer) for _, renderer := range g.renderers { z := g.options.Print.InitialLayerThickness + data.Micrometer(layerNr)*g.options.Print.LayerThickness err := renderer.Render(g.builder, layerNr, maxLayer, layers[layerNr], z, g.options) diff --git a/gcode/generator_test.go b/gcode/generator_test.go index be8c38b..5e05b9e 100644 --- a/gcode/generator_test.go +++ b/gcode/generator_test.go @@ -4,6 +4,7 @@ import ( "github.com/aligator/goslice/data" "github.com/aligator/goslice/gcode" "github.com/aligator/goslice/util/test" + "log" "testing" ) @@ -38,7 +39,11 @@ func TestGCodeGenerator(t *testing.T) { layers := make([]data.PartitionedLayer, 3) - generator := gcode.NewGenerator(&data.Options{}, gcode.WithRenderer(&fakeRenderer{t: t, c: rendererCounter})) + generator := gcode.NewGenerator(&data.Options{ + GoSlice: data.GoSliceOptions{ + Logger: log.Default(), + }, + }, gcode.WithRenderer(&fakeRenderer{t: t, c: rendererCounter})) generator.Init(nil) result, err := generator.Generate(layers) diff --git a/goslice.go b/goslice.go index 38af683..d96b64d 100644 --- a/goslice.go +++ b/goslice.go @@ -125,18 +125,20 @@ func (s *GoSlice) Process() error { startTime := time.Now() // 1. Load model + s.Options.Logger.Printf("Load model %v\n", s.Options.InputFilePath) models, err := s.Reader.Read(s.Options.InputFilePath) if err != nil { return err } + s.Options.Logger.Printf("Model loaded.\nFace count: %v\nSize: min: %v max %v\n", models.FaceCount(), models.Min(), models.Max()) // 2. Optimize model var optimizedModel data.OptimizedModel - optimizedModel, err = s.Optimizer.Optimize(models) if err != nil { return err } + s.Options.Logger.Printf("Model optimized\n") //err = optimizedModel.SaveDebugSTL("test.stl") //if err != nil { @@ -148,6 +150,7 @@ func (s *GoSlice) Process() error { if err != nil { return err } + s.Options.Logger.Printf("Model sliced to %v layers\n", len(layers)) // 4. Modify the layers // e.g. generate perimeter paths, @@ -158,7 +161,9 @@ func (s *GoSlice) Process() error { if err != nil { return err } + s.Options.Logger.Printf("Modifier %s applied\n", m.GetName()) } + s.Options.Logger.Printf("Layers modified %v\n", len(layers)) // 5. generate gcode from the layers s.Generator.Init(optimizedModel) diff --git a/handler/handler.go b/handler/handler.go index 5eadcb0..6d0498b 100644 --- a/handler/handler.go +++ b/handler/handler.go @@ -4,6 +4,18 @@ package handler import "github.com/aligator/goslice/data" +type Namer interface { + GetName() string +} + +type Named struct { + Name string +} + +func (n Named) GetName() string { + return n.Name +} + // ModelReader reads a model from a file. type ModelReader interface { Read(filename string) (data.Model, error) @@ -21,6 +33,7 @@ type ModelSlicer interface { // LayerModifier can add new attributes to the layers or even alter the layer directly. type LayerModifier interface { + Namer Init(m data.OptimizedModel) Modify(layers []data.PartitionedLayer) error } diff --git a/modifier/brim.go b/modifier/brim.go index 815fba6..c775d1c 100644 --- a/modifier/brim.go +++ b/modifier/brim.go @@ -8,6 +8,7 @@ import ( ) type brimModifier struct { + handler.Named options *data.Options } @@ -25,6 +26,9 @@ func (m brimModifier) Init(model data.OptimizedModel) {} // "outerBrim" just contains the outline of the brim (taking into account the line width also). func NewBrimModifier(options *data.Options) handler.LayerModifier { return &brimModifier{ + Named: handler.Named{ + Name: "Brim", + }, options: options, } } diff --git a/modifier/infill.go b/modifier/infill.go index 75be514..dbf51be 100644 --- a/modifier/infill.go +++ b/modifier/infill.go @@ -8,6 +8,7 @@ import ( ) type infillModifier struct { + handler.Named options *data.Options } @@ -16,6 +17,9 @@ func (m infillModifier) Init(model data.OptimizedModel) {} // NewInfillModifier calculates the areas which need infill and passes them as "bottom" attribute to the layer. func NewInfillModifier(options *data.Options) handler.LayerModifier { return &infillModifier{ + Named: handler.Named{ + Name: "Infill", + }, options: options, } } diff --git a/modifier/internal_infill.go b/modifier/internal_infill.go index 2e4ff8a..a630bcb 100644 --- a/modifier/internal_infill.go +++ b/modifier/internal_infill.go @@ -8,6 +8,7 @@ import ( ) type internalInfillModifier struct { + handler.Named options *data.Options } @@ -16,6 +17,9 @@ func (m internalInfillModifier) Init(model data.OptimizedModel) {} // NewInfillModifier calculates the areas which need infill and passes them as "bottom" attribute to the layer. func NewInternalInfillModifier(options *data.Options) handler.LayerModifier { return &internalInfillModifier{ + Named: handler.Named{ + Name: "InternalInfill", + }, options: options, } } diff --git a/modifier/perimeter.go b/modifier/perimeter.go index 1e10bc8..ac13042 100644 --- a/modifier/perimeter.go +++ b/modifier/perimeter.go @@ -8,6 +8,7 @@ import ( ) type perimeterModifier struct { + handler.Named options *data.Options } @@ -16,6 +17,9 @@ type perimeterModifier struct { // The perimeters are saved as attribute in the LayerPart. func NewPerimeterModifier(options *data.Options) handler.LayerModifier { return &perimeterModifier{ + Named: handler.Named{ + Name: "Perimeter", + }, options: options, } } diff --git a/modifier/support.go b/modifier/support.go index 55ac0f3..89045b4 100644 --- a/modifier/support.go +++ b/modifier/support.go @@ -31,6 +31,7 @@ func FullSupport(layer data.PartitionedLayer) ([]data.LayerPart, error) { } type supportDetectorModifier struct { + handler.Named options *data.Options } @@ -63,6 +64,9 @@ func (m supportDetectorModifier) Init(_ data.OptimizedModel) {} // All areas that remain have a higher angle than the threshold and need to be supported." func NewSupportDetectorModifier(options *data.Options) handler.LayerModifier { return &supportDetectorModifier{ + Named: handler.Named{ + Name: "SupportDetector", + }, options: options, } } @@ -108,6 +112,7 @@ func (m supportDetectorModifier) Modify(layers []data.PartitionedLayer) error { } type supportGeneratorModifier struct { + handler.Named options *data.Options } @@ -119,6 +124,9 @@ func (m supportGeneratorModifier) Init(_ data.OptimizedModel) {} // and removes them from the normal support areas. func NewSupportGeneratorModifier(options *data.Options) handler.LayerModifier { return &supportGeneratorModifier{ + Named: handler.Named{ + Name: "SupportGenerator", + }, options: options, } } diff --git a/slicer/slicer.go b/slicer/slicer.go index 2fde063..e3cd091 100644 --- a/slicer/slicer.go +++ b/slicer/slicer.go @@ -32,7 +32,6 @@ func NewSlicer(options *data.Options) handler.ModelSlicer { func (s slicer) Slice(m data.OptimizedModel) ([]data.PartitionedLayer, error) { layerCount := (m.Size().Z()-s.options.Print.InitialLayerThickness)/s.options.Print.LayerThickness + 1 - s.options.GoSlice.Logger.Println("layer count:", layerCount) layers := make([]*layer, layerCount)