diff options
Diffstat (limited to 'autoutils')
| -rw-r--r-- | autoutils/audio.go | 99 | ||||
| -rw-r--r-- | autoutils/batches.go | 49 | ||||
| -rw-r--r-- | autoutils/colorconversion.go | 65 | ||||
| -rw-r--r-- | autoutils/functiongenerator.go | 264 |
4 files changed, 251 insertions, 226 deletions
diff --git a/autoutils/audio.go b/autoutils/audio.go index 19ae5f3..67fe923 100644 --- a/autoutils/audio.go +++ b/autoutils/audio.go @@ -20,46 +20,69 @@ along with AutoArt. If not, see <https://www.gnu.org/licenses/>. package autoutils import ( - "io" - "encoding/binary" + "encoding/binary" + "io" ) // Write a header to writer. You need to decide ahead of time how many samples // you want. func WriteAudioHeader(writer io.Writer, nSamples int64, channels, sampleRate int32) error { - w := func (data interface{}) error { - return binary.Write(writer, binary.LittleEndian, data) - } - var err error - if err = w([]byte("RIFF")); err != nil { return err } - var chunkSize1 uint32 = 36 + uint32(nSamples) - if err = w(chunkSize1); err != nil { return err } - if err = w([]byte("WAVEfmt ")); err != nil { return err } - var subchunk1size uint32 = 16 - if err = w(subchunk1size); err != nil { return err } - var audioFormat uint16 = 1 - if err = w(audioFormat); err != nil { return err } - var nChannels uint16 = uint16(channels) - if err = w(nChannels); err != nil { return err } - var srate uint32 = uint32(sampleRate) - if err = w(srate); err != nil { return err } - var byteRate uint32 = srate * uint32(nChannels) - if err = w(byteRate); err != nil { return err } - var blockAlign uint16 = nChannels - if err = w(blockAlign); err != nil { return err } - var bitsPerSample uint16 = 8 - if err = w(bitsPerSample); err != nil { return err } - if err = w([]byte("data")); err != nil { return err } - var chunkSize2 uint32 = uint32(nSamples) * uint32(nChannels) - if err = w(chunkSize2); err != nil { return err } - return nil + w := func(data interface{}) error { + return binary.Write(writer, binary.LittleEndian, data) + } + var err error + if err = w([]byte("RIFF")); err != nil { + return err + } + var chunkSize1 uint32 = 36 + uint32(nSamples) + if err = w(chunkSize1); err != nil { + return err + } + if err = w([]byte("WAVEfmt ")); err != nil { + return err + } + var subchunk1size uint32 = 16 + if err = w(subchunk1size); err != nil { + return err + } + var audioFormat uint16 = 1 + if err = w(audioFormat); err != nil { + return err + } + var nChannels uint16 = uint16(channels) + if err = w(nChannels); err != nil { + return err + } + var srate uint32 = uint32(sampleRate) + if err = w(srate); err != nil { + return err + } + var byteRate uint32 = srate * uint32(nChannels) + if err = w(byteRate); err != nil { + return err + } + var blockAlign uint16 = nChannels + if err = w(blockAlign); err != nil { + return err + } + var bitsPerSample uint16 = 8 + if err = w(bitsPerSample); err != nil { + return err + } + if err = w([]byte("data")); err != nil { + return err + } + var chunkSize2 uint32 = uint32(nSamples) * uint32(nChannels) + if err = w(chunkSize2); err != nil { + return err + } + return nil } - // Writes some samples to the writer. You will need to write a header before // any samples. func WriteAudioSamples(writer io.Writer, samples []uint8) error { - return binary.Write(writer, binary.LittleEndian, samples) + return binary.Write(writer, binary.LittleEndian, samples) } /* @@ -72,12 +95,12 @@ you're using that many?!) */ func WriteAudio(writer io.Writer, audio []uint8, channels, sampleRate int32) error { - err := WriteAudioHeader(writer, int64(len(audio)), channels, sampleRate) - if err != nil { - return err - } - if err = WriteAudioSamples(writer, audio); err != nil { - return err - } - return nil + err := WriteAudioHeader(writer, int64(len(audio)), channels, sampleRate) + if err != nil { + return err + } + if err = WriteAudioSamples(writer, audio); err != nil { + return err + } + return nil } diff --git a/autoutils/batches.go b/autoutils/batches.go index fb39fc1..7e27473 100644 --- a/autoutils/batches.go +++ b/autoutils/batches.go @@ -20,7 +20,7 @@ along with AutoArt. If not, see <https://www.gnu.org/licenses/>. package autoutils import ( - "fmt" + "fmt" ) /* @@ -31,26 +31,27 @@ a message will be printed, starting with progress, and showing how many batches have been completed so far out of the total number of batches. */ const batchSize = 32 -func RunInBatches(number int64, progress string, f func (n int64, errs chan<- error)) error { - nBatches := number / batchSize - errs := make(chan error) - for batch := int64(0); batch <= nBatches; batch++ { - fmt.Println(progress, batch+1, "/", nBatches+1) - thisBatchSize := batchSize - if batch == nBatches { - // Deal with case of last batch - thisBatchSize = int(number - nBatches * batchSize) - } - for task := 0; task < thisBatchSize; task++ { - go f(int64(task) + batchSize * batch, errs) - } - - for completed := 0; completed < thisBatchSize; completed++ { - err := <-errs - if err != nil { - return err - } - } - } - return nil -}
\ No newline at end of file + +func RunInBatches(number int64, progress string, f func(n int64, errs chan<- error)) error { + nBatches := number / batchSize + errs := make(chan error) + for batch := int64(0); batch <= nBatches; batch++ { + fmt.Println(progress, batch+1, "/", nBatches+1) + thisBatchSize := batchSize + if batch == nBatches { + // Deal with case of last batch + thisBatchSize = int(number - nBatches*batchSize) + } + for task := 0; task < thisBatchSize; task++ { + go f(int64(task)+batchSize*batch, errs) + } + + for completed := 0; completed < thisBatchSize; completed++ { + err := <-errs + if err != nil { + return err + } + } + } + return nil +} diff --git a/autoutils/colorconversion.go b/autoutils/colorconversion.go index af21668..6128e39 100644 --- a/autoutils/colorconversion.go +++ b/autoutils/colorconversion.go @@ -18,40 +18,41 @@ along with AutoArt. If not, see <https://www.gnu.org/licenses/>. */ package autoutils + import ( - "math" + "math" ) func HSVToRGB(h uint8, s uint8, v uint8) (uint8, uint8, uint8) { - // https://en.wikipedia.org/wiki/HSL_and_HSV#HSV_to_RGB - V := float64(v) / 256 - S := float64(s) / 256 - C := V * S - H := float64(h) / (256/6) - X := float64(C) * (1 - math.Abs(math.Mod(H, 2) - 1)) - var r, g, b float64 - switch true { - case s == 0: - r, g, b = 0, 0, 0 - case H <= 1: - r, g, b = C, X, 0 - case H <= 2: - r, g, b = X, C, 0 - case H <= 3: - r, g, b = 0, C, X - case H <= 4: - r, g, b = 0, X, C - case H <= 5: - r, g, b = X, 0, C - default: - r, g, b = C, 0, X - } - m := V - C - r += m - g += m - b += m - r *= 255 - g *= 255 - b *= 255 - return uint8(r), uint8(g), uint8(b) + // https://en.wikipedia.org/wiki/HSL_and_HSV#HSV_to_RGB + V := float64(v) / 256 + S := float64(s) / 256 + C := V * S + H := float64(h) / (256 / 6) + X := float64(C) * (1 - math.Abs(math.Mod(H, 2)-1)) + var r, g, b float64 + switch true { + case s == 0: + r, g, b = 0, 0, 0 + case H <= 1: + r, g, b = C, X, 0 + case H <= 2: + r, g, b = X, C, 0 + case H <= 3: + r, g, b = 0, C, X + case H <= 4: + r, g, b = 0, X, C + case H <= 5: + r, g, b = X, 0, C + default: + r, g, b = C, 0, X + } + m := V - C + r += m + g += m + b += m + r *= 255 + g *= 255 + b *= 255 + return uint8(r), uint8(g), uint8(b) } diff --git a/autoutils/functiongenerator.go b/autoutils/functiongenerator.go index 7acb680..20ab0e0 100644 --- a/autoutils/functiongenerator.go +++ b/autoutils/functiongenerator.go @@ -20,27 +20,27 @@ along with AutoArt. If not, see <https://www.gnu.org/licenses/>. package autoutils import ( - "math" - "math/rand" - "fmt" + "fmt" + "math" + "math/rand" ) // Operators const ( - CONST = iota - ADD - SUB - MUL - DIV + CONST = iota + ADD + SUB + MUL + DIV MIN MAX - SQRT - SIN - COS - TAN + SQRT + SIN + COS + TAN LOG EXP - OPERATOR_COUNT + OPERATOR_COUNT ) const FIRST_BINARY = ADD const FIRST_UNARY = SQRT @@ -49,147 +49,147 @@ const UNARY_COUNT = OPERATOR_COUNT - FIRST_UNARY const FIRST_VAR = OPERATOR_COUNT type Operator struct { - op int // Operator number. If operator is a variable, v, it is equal to FIRST_VAR + v - constant float64 // Constant (if op = CONST) + op int // Operator number. If operator is a variable, v, it is equal to FIRST_VAR + v + constant float64 // Constant (if op = CONST) } type Function struct { - nvars int - operators []Operator + nvars int + operators []Operator } // Generate a random function f with the given length (i.e. len(f.operators)) // and the given number of variables func (f *Function) Generate(nvars int, length int) { - f.nvars = nvars - f.operators = make([]Operator, length) - nsOnStack := 0 - i := 0 - for nsOnStack + i < length { - var operator Operator - var optype int - if nsOnStack == 0 { - // Pick a random variable - optype = 0 - } else if nsOnStack == 1 { - // Pick a constant/variable/unary operator - optype = rand.Intn(3) - } else { - // Pick a constant/variable/unary/binary operator - optype = rand.Intn(4) - } - switch optype { - case 0: - // variable - operator.op = FIRST_VAR + rand.Intn(nvars) - nsOnStack++ - case 1: - // Constant - operator.op = CONST - operator.constant = rand.Float64() - nsOnStack++ - case 2: - // unary - operator.op = rand.Intn(UNARY_COUNT) + FIRST_UNARY - case 3: - // binary - operator.op = rand.Intn(BINARY_COUNT) + FIRST_BINARY - nsOnStack-- - } - f.operators[i] = operator - i++ - } - - if nsOnStack + i == length { - // Add a unary operator - f.operators[i].op = rand.Intn(UNARY_COUNT) + FIRST_UNARY - i++ - } - - // Keep adding binary operators until nsOnStack == 1 - for nsOnStack > 1 { - f.operators[i].op = rand.Intn(BINARY_COUNT) + FIRST_BINARY - nsOnStack-- - i++ - } + f.nvars = nvars + f.operators = make([]Operator, length) + nsOnStack := 0 + i := 0 + for nsOnStack+i < length { + var operator Operator + var optype int + if nsOnStack == 0 { + // Pick a random variable + optype = 0 + } else if nsOnStack == 1 { + // Pick a constant/variable/unary operator + optype = rand.Intn(3) + } else { + // Pick a constant/variable/unary/binary operator + optype = rand.Intn(4) + } + switch optype { + case 0: + // variable + operator.op = FIRST_VAR + rand.Intn(nvars) + nsOnStack++ + case 1: + // Constant + operator.op = CONST + operator.constant = rand.Float64() + nsOnStack++ + case 2: + // unary + operator.op = rand.Intn(UNARY_COUNT) + FIRST_UNARY + case 3: + // binary + operator.op = rand.Intn(BINARY_COUNT) + FIRST_BINARY + nsOnStack-- + } + f.operators[i] = operator + i++ + } + + if nsOnStack+i == length { + // Add a unary operator + f.operators[i].op = rand.Intn(UNARY_COUNT) + FIRST_UNARY + i++ + } + + // Keep adding binary operators until nsOnStack == 1 + for nsOnStack > 1 { + f.operators[i].op = rand.Intn(BINARY_COUNT) + FIRST_BINARY + nsOnStack-- + i++ + } } func (f *Function) Evaluate(vars []float64) float64 { - var stack []float64 - for _, op := range f.operators { - l := len(stack) - switch (op.op) { - case CONST: - stack = append(stack, op.constant) - case ADD: - stack[l-2] += stack[l-1] - stack = stack[:l-1] - case SUB: - stack[l-2] -= stack[l-1] - stack = stack[:l-1] - case MUL: - stack[l-2] *= stack[l-1] - stack = stack[:l-1] - case DIV: - if stack[l-1] == 0 { // Check for division by 0 - stack[l-1] = 0.01 - } - stack[l-2] /= stack[l-1] - stack = stack[:l-1] + var stack []float64 + for _, op := range f.operators { + l := len(stack) + switch op.op { + case CONST: + stack = append(stack, op.constant) + case ADD: + stack[l-2] += stack[l-1] + stack = stack[:l-1] + case SUB: + stack[l-2] -= stack[l-1] + stack = stack[:l-1] + case MUL: + stack[l-2] *= stack[l-1] + stack = stack[:l-1] + case DIV: + if stack[l-1] == 0 { // Check for division by 0 + stack[l-1] = 0.01 + } + stack[l-2] /= stack[l-1] + stack = stack[:l-1] case MIN: stack[l-2] = math.Min(stack[l-2], stack[l-1]) stack = stack[:l-1] case MAX: stack[l-2] = math.Max(stack[l-2], stack[l-1]) stack = stack[:l-1] - case SQRT: - stack[l-1] = math.Sqrt(math.Abs(stack[l-1])) - case SIN: - stack[l-1] = math.Sin(stack[l-1]) - case COS: - stack[l-1] = math.Cos(stack[l-1]) - case TAN: - stack[l-1] = math.Tan(stack[l-1]) + case SQRT: + stack[l-1] = math.Sqrt(math.Abs(stack[l-1])) + case SIN: + stack[l-1] = math.Sin(stack[l-1]) + case COS: + stack[l-1] = math.Cos(stack[l-1]) + case TAN: + stack[l-1] = math.Tan(stack[l-1]) case LOG: stack[l-1] = math.Log(math.Abs(stack[l-1])) case EXP: stack[l-1] = math.Exp(stack[l-1]) - default: - stack = append(stack, vars[op.op - FIRST_VAR]) - } - } - return stack[0] + default: + stack = append(stack, vars[op.op-FIRST_VAR]) + } + } + return stack[0] } func (f *Function) String() string { - var str string - for _, op := range f.operators { - switch (op.op) { - case CONST: - str += fmt.Sprintf("%v",op.constant) - case ADD: - str += "+" - case SUB: - str += "-" - case MUL: - str += "*" - case DIV: - str += "/" - case SQRT: - str += "sqrt" - case SIN: - str += "sin" - case COS: - str += "cos" - case TAN: - str += "tan" - default: - str += fmt.Sprintf("v%v", op.op - FIRST_VAR) - } - str += " " - } - return str + var str string + for _, op := range f.operators { + switch op.op { + case CONST: + str += fmt.Sprintf("%v", op.constant) + case ADD: + str += "+" + case SUB: + str += "-" + case MUL: + str += "*" + case DIV: + str += "/" + case SQRT: + str += "sqrt" + case SIN: + str += "sin" + case COS: + str += "cos" + case TAN: + str += "tan" + default: + str += fmt.Sprintf("v%v", op.op-FIRST_VAR) + } + str += " " + } + return str } const mutationRate = 0.01 @@ -202,14 +202,14 @@ func (f *Function) Mutate() { } } -func (f *Function) Breed(f1* Function, f2 *Function) { +func (f *Function) Breed(f1 *Function, f2 *Function) { // f(x) = (f1(x) + f2(x)) / 2 - f.operators = make([]Operator, len(f1.operators) + len(f2.operators) + 3) + f.operators = make([]Operator, len(f1.operators)+len(f2.operators)+3) for i, o := range f1.operators { f.operators[i] = o } for i, o := range f2.operators { - f.operators[i + len(f1.operators)] = o + f.operators[i+len(f1.operators)] = o } i := len(f1.operators) + len(f2.operators) f.operators[i].op = ADD |