// handler that displays lissajous figures in the browser
func lissajous(out io.Writer) {
hit() // Increment 'total hits' metric
l_start := time.Now()
const (
cycles = 5 // number of complete x oscillator revolutions
res = 0.001 // angular resolution
size = 400 // image canvas covers [-size..+size]
nframes = 64 // number of animation frames
delay = 8 // delay between frames in 10ms units
)
freq := rand.Float64() * 3.0 // relative frequency of y oscillator
anim := gif.GIF{LoopCount: nframes}
phase := 0.0 // phase difference
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
for t := 0.0; t < cycles*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5),
blackIndex)
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim) // NOTE: ignoring encoding errors
l_secs := time.Since(l_start).Seconds()
stats.Timing("lissajous.load.time", int64(l_secs)) // Metric to record time to load a figure
stats.Incr("lissajous.pageview.count", 1) // Metric to record hits per cycle for this handler
}
func lissajous(out io.Writer, c float64, col color.RGBA) {
var palette = []color.Color{color.White, col}
const (
res = 0.01 // angular resolution
size = 100 // image canvas covers [-size ... +size]
nframes = 64 // number of animation frames
delay = 8 // delay between frames in 10ms units
)
freq := rand.Float64() * 3
anim := gif.GIF{LoopCount: nframes}
phase := 0.0
cycles := float64(c)
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
for t := 0.0; t < cycles*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), blackIndex)
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim)
}
func lissajous(out io.Writer) {
const (
cycles = 5 // number of complete x oscillator revolutions
res = 0.001 // angular resolution
size = 100 // image canvas covers [-size..+size]
nframes = 64 // number of animation frames
delay = 8 // delay between frames in 10ms units
)
freq := rand.Float64() * 3.0 // relative frequency of y oscillator
anim := gif.GIF{LoopCount: nframes}
phase := 0.0 // phase difference
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
for t := 0.0; t < cycles*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), uint8(i)%3+1)
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim) // NOTE: ignoring encoding errors
}
func lissajous(out io.Writer) {
const (
cycles = 5
res = 0.001
size = 100
nframes = 64
delay = 8
)
freq := rand.Float64() * 3.0
anim := gif.GIF{LoopCount: nframes}
phase := 0.0
for i := 0; i < nframes; i++ {
colorIndex := uint8(blackIndex)
switch {
case i%9 <= 2:
colorIndex = greenIndex
case i%9 >= 3 && i%9 <= 5:
colorIndex = redIndex
case i%9 >= 6 && i%9 <= 8:
colorIndex = blueIndex
}
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
for t := 0.0; t < cycles*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), colorIndex)
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim)
}
func lissajous(out io.Writer) {
palette := []color.Color{color.Black}
for i := 0; i < nFrames; i++ {
red := (uint8)((i * 255) / nFrames)
green := (uint8)(((i + nFrames/2) * 255) / nFrames)
blue := (uint8)(((nFrames/2 - i) * 255) / nFrames)
palette = append(palette, color.RGBA{red, green, blue, 0xff})
}
freq := rand.Float64() * 3.0 // relative frequency of y oscillator
anim := gif.GIF{LoopCount: nFrames}
phase := 0.0
for i := 0; i < nFrames; i++ {
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
for t := 0.0; t < cycles*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
xcoord := size + int(x*(float64)(size)+0.5)
ycoord := size + int(y*(float64)(size)+0.5)
img.SetColorIndex(xcoord, ycoord, (uint8)(i+1))
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim)
}
// Process implements Processor.
func (prc *SimpleProcessor) Process(g *gif.GIF, params imageserver.Params) (*gif.GIF, error) {
out := new(gif.GIF)
var err error
out.Image, err = prc.processImages(g.Image, params)
if err != nil {
return nil, err
}
out.Delay = make([]int, len(g.Delay))
copy(out.Delay, g.Delay)
out.LoopCount = g.LoopCount
if g.Disposal != nil {
out.Disposal = make([]byte, len(g.Disposal))
copy(out.Disposal, g.Disposal)
}
out.Config.ColorModel = g.Config.ColorModel
for _, p := range out.Image {
if p.Rect.Max.X > out.Config.Width {
out.Config.Width = p.Rect.Max.X
}
if p.Rect.Max.Y > out.Config.Height {
out.Config.Height = p.Rect.Max.Y
}
}
out.BackgroundIndex = g.BackgroundIndex
return out, nil
}
func generateGIF(filenames []string, outPath string) error {
fmt.Printf("Generating GIF in %s\n", outPath)
uiprogress.Start()
bar := uiprogress.AddBar(len(filenames)).AppendCompleted()
anim := gif.GIF{LoopCount: len(filenames)}
for _, filename := range filenames {
reader, err := os.Open(filename)
if err != nil {
return err
}
defer reader.Close()
img, _, err := image.Decode(reader)
if err != nil {
return err
}
bounds := img.Bounds()
drawer := draw.FloydSteinberg
palettedImg := image.NewPaletted(bounds, palette.Plan9)
drawer.Draw(palettedImg, bounds, img, image.ZP)
anim.Image = append(anim.Image, palettedImg)
anim.Delay = append(anim.Delay, *delay)
bar.Incr()
}
file, err := os.Create(outPath)
defer file.Close()
if err != nil {
return err
}
encodeErr := gif.EncodeAll(file, &anim)
if encodeErr != nil {
return encodeErr
}
return nil
}
func lissajous(out io.Writer, cycles int) {
rand.Seed(time.Now().UTC().UnixNano())
const (
res = 0.001
size = 100
nframes = 64
delay = 8
)
freq := rand.Float64() * 3.0 // relative frequency of y oscillator
anim := gif.GIF{LoopCount: nframes}
phase := 0.0 // phase difference
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
for t := 0.0; t < float64(cycles)*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5),
uint8(1+rand.Intn(4-1))) // randomly generated color
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim) // NOTE: ignoring encoding errors
}
func lissajous(out io.Writer, user_vals map[string]Float) {
const (
res = 0.001 // angular resolution
)
vals := combineUserAndDefaultVals(user_vals)
cycles := vals["cycles"]
size := vals["size"]
nframes := vals["nframes"]
delay := vals["delay"]
fmt.Printf("%d %d %d %d\n", cycles, size, nframes, delay)
freq := rand.Float64() * 3.0 // relative frequency of y oscillator
anim := gif.GIF{LoopCount: nframes}
phase := 0.0 // phase difference
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
for t := 0.0; t < cycles*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5),
linesIndex)
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim) // NOTE: ignoring encoding errors
}
func animate(animdata []byte, frames []*image.Paletted) *gif.GIF {
var g gif.GIF
var loop, clock int
loop:
for pc := 0; ; pc += 2 {
//log.Println("PC", pc)
switch animdata[pc] {
case 0xFF:
break loop
case 0xFE:
loop = int(animdata[pc+1])
case 0xFD:
if loop > 0 {
pc = int(animdata[pc+1]) * 2
pc -= 2
loop--
}
default:
delay := int(animdata[pc+1])
g.Image = append(g.Image, frames[animdata[pc]])
//g.Delay = append(g.Delay, delay*100/60)
g.Delay = append(g.Delay, (clock+delay)*100/60-clock*100/60)
clock += delay
}
}
g.Image = append(g.Image, frames[0])
g.Delay = append(g.Delay, clock*2*100/60-clock)
return &g
}
func lissajous(write http.ResponseWriter, read *http.Request) {
const (
res = 0.001 // angular resolution
size = 100 // image canvas covers [-size..+size]
nframes = 64 // number of animation frames
delay = 8 // delay between frames in 10ms units
)
cycles, _ := strconv.Atoi(read.URL.Query()["cycles"][0])
freq := rand.Float64() * 3.0 // relative frequency of y oscillator
anim := gif.GIF{LoopCount: nframes}
phase := 0.0 // phase difference
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
for t := 0.0; t < float64(cycles)*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5),
blackIndex)
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(write, &anim) // NOTE: ignoring encoding errors
}
func lissajous(out io.Writer) {
const (
cycles = 5
res = 0.001
size = 100
nframes = 64
delay = 8
)
freq := rand.Float64() * 3.0
anim := gif.GIF{LoopCount: nframes}
phase := 0.0
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
for t := 0.0; t < cycles*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), greenIndex)
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
err := gif.EncodeAll(out, &anim)
if err != nil {
panic("Gif encoding error")
}
}
func (bam *BAM) MakeGif(outputPath string, name string) error {
for idx, seq := range bam.Sequences {
if seq.Start >= 0 && seq.Count > 0 {
pathname := filepath.Join(outputPath, fmt.Sprintf("%s_%03d.gif", name, idx))
g := gif.GIF{}
g.Image = make([]*image.Paletted, seq.Count)
g.Delay = make([]int, seq.Count)
g.LoopCount = 0
for iIdx := seq.Start; iIdx < seq.Start+seq.Count; iIdx++ {
imgIdx := int(bam.SequenceToImage[iIdx])
g.Image[iIdx-seq.Start] = &bam.Image[imgIdx]
g.Delay[iIdx-seq.Start] = 10
}
outFile, err := os.Create(pathname)
if err != nil {
return fmt.Errorf("Unable to create file %s: %v", pathname, err)
}
gif.EncodeAll(outFile, &g)
outFile.Close()
}
}
return nil
}
func lissajous(out http.ResponseWriter, r *http.Request) {
const (
cycles = 5
res = 0.001
size = 100
nframes = 64
delay = 8
)
freq := rand.Float64() * 3.0
anim := gif.GIF{LoopCount: nframes}
phase := 0.0
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
for t := 0.0; t < cycles*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), blackIndex)
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim)
}
func lissajous(out io.Writer) {
const (
cycles = 5 // number of complete x oscillator revolutions
res = 0.001 // angular resolution
size = 100 // image canvas covers [-size..+size]
nframes = 64 // number of animation frames
delay = 8 // delay between frames in 10ms units
)
freq := rand.Float64() * 3.0 // relative frequency of y oscillator
anim := gif.GIF{LoopCount: nframes}
phase := 0.0 // phase difference
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
index := uint8(rand.Int() % len(palette)) // random palette index color
if index == 0 {
index = 1 // change the index if the color is the same as the background color
}
for t := 0.0; t < cycles*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), index)
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
if err := gif.EncodeAll(out, &anim); err != nil {
log.Fatal(err)
}
}
// Writter writes a Gif
// @param out a Writter
// @param cycles number of complete x oscillator revolutions
func Writter(out io.Writer, cycles float64) {
const (
res = 0.001 // angular resolution
size = 100 // image canvas covers [-size..+size]
nframes = 64 // number of animation frames
delay = 8 // delay between frames in 10ms units
)
freq := rand.Float64() * 12.0 // relative frequency of y oscillator
anim := gif.GIF{LoopCount: nframes}
phase := 0.0 // phase difference
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, pallete)
for t := 0.0; t < cycles*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
if i%2 == 0 {
img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), greenIndex)
} else {
img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), blueIndex)
}
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim)
}
func lissajous(out io.Writer) {
const (
cycles = 5
res = 0.001
size = 100
nframes = 128
delay = 24
)
genGradientPalette(nframes)
freq := rand.Float64() * 3.0
anim := gif.GIF{LoopCount: nframes}
phase := 0.0
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
for t := 0.0; t < cycles*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), uint8(i+1))
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim)
}
func composite(input *gif.GIF, lgtm image.Image) (*gif.GIF, error) {
output := gif.GIF{
Delay: input.Delay,
LoopCount: input.LoopCount,
Disposal: input.Disposal,
Config: image.Config{
Width: input.Config.Width,
Height: input.Config.Height,
},
}
x := input.Config.Width/2 - lgtm.Bounds().Dx()/2
y := input.Config.Height/2 - lgtm.Bounds().Dy()/2
fmt.Print("compositting frame...")
for i, frame := range input.Image {
fmt.Printf("%d ", i+1)
draw.Draw(frame, frame.Bounds(), lgtm, image.Point{-x, -y}, draw.Over)
output.Image = append(output.Image, frame)
}
fmt.Println("done")
return &output, nil
}
func lissajous(out http.ResponseWriter, r *http.Request) {
const (
res = 0.001 // angular resolution
size = 500 // image canvas covers [-size..+size]
nframes = 64 // number of animation frames
delay = 8 // delay between frames in 10ms units
)
if err := r.ParseForm(); err != nil {
os.Exit(1)
}
for k, v := range r.Form {
fmt.Printf("%s:%s\n", k, v)
}
cyclesInt, _ := strconv.Atoi(r.Form.Get("cycles")) // number of complete x oscillator revolutions
cycles := float64(cyclesInt)
fmt.Printf("Float is: %f\n", cycles)
freq := rand.Float64() * 3.0 // relative frequency of y oscillator
anim := gif.GIF{LoopCount: nframes}
phase := 0.0 // phase difference
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
for t := 0.0; t < cycles*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5),
blackIndex)
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim) // NOTE: ignoring encoding errors
}
func lissajous(out io.Writer) {
const (
cycles = 5 // number of complete x oscillator revolutions
res = 0.001 // angular resolution
size = 100 // image canvas covers [-size..+size]
nframes = 64 // number of animation frames
delay = 8 // delay between frames in 10ms units
)
freq := rand.Float64() * 3.0 // relative frequency of y oscillator
// gif.GIF is a struct type. Somehow this allows the struct to be initialized with nframes,
// the rest are 0 due to some defaulting.
anim := gif.GIF{LoopCount: nframes}
phase := 0.0 // phase difference
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
for t := 0.0; t < cycles*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
// BobK: I have no idea what int(x*size+0.5) is doing
img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5),
blackIndex)
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim) // NOTE: ignoring encoding errors
}
func lissajous(out io.Writer) {
const (
cycles = 5
res = 0.001
size = 100
nframes = 64
delay = 8
)
freq := rand.Float64() * 3.0 // relative frequency of y oscillator
anim := gif.GIF{LoopCount: nframes}
phase := 0.0 // phase difference
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
for t := 0.0; t < cycles*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), greenIndex)
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim) // NOTE: ignoring encoding errors
}
func lissajous(out io.Writer, config map[string]int) {
cycles := 5 // number of complete x oscillator revolutions
res := 0.001 // angular resolution
size := 100 // image canvas covers [-size..+size]
nframes := 63 // number of animation frames
delay := 8 // delay between frames in 10ms units
if v, ok := config["cycles"]; ok {
cycles = v
}
if v, ok := config["size"]; ok {
size = v
}
freq := rand.Float64() * 3.0 // relative frequency of y oscillator
anim := gif.GIF{LoopCount: nframes}
phase := 0.0 // phase difference
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
for t := 0.0; t < float64(cycles)*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
img.SetColorIndex(size+int(x*float64(size)+0.5), size+int(y*float64(size)+0.5),
greenIndex)
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim) // NOTE: ignoring encoding errors
}
func lissajous(out io.Writer, cycles int) {
palette := []color.Color{color.White, color.Black}
const (
res = 0.001
size = 100
nframes = 64
delay = 8
whiteIndex = 0
blackIndex = 1
)
freq := rand.Float64() * 3.0 // relative Frequency of y oscillator
anim := gif.GIF{LoopCount: nframes}
phase := 0.0
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
for t := 0.0; t < cycles*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5),
blackIndex)
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim)
}
func lissajous(out io.Writer, cycles int) {
if cycles == 0 {
cycles = 5
}
const (
res = 0.001
size = 100
nframes = 64
delay = 8
)
freq := rand.Float64() * 3.0
anim := gif.GIF{LoopCount: nframes}
phase := 0.0
for i := 0; i < nframes; i++ {
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
color := rand.Intn(216)
for t := 0.0; t < float64(cycles)*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), uint8(color))
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim)
}
func makeGif(c appengine.Context, m *movie) ([]byte, error) {
palette := m.palette()
delay := int(100 / m.Speed)
anim := gif.GIF{LoopCount: 0}
for _, pix := range m.Frames {
bounds := image.Rect(0, 0, m.Width*pixelsize, m.Height*pixelsize)
scaled := make([]byte, bounds.Max.X*bounds.Max.Y)
idx := 0
for y := 0; y < m.Height; y++ {
for i := 0; i < pixelsize; i++ {
for x := 0; x < m.Width; x++ {
pixel := pix[x+y*m.Width] - startColorChar
for j := 0; j < pixelsize; j++ {
scaled[idx] = pixel
idx++
}
}
}
}
img := image.Paletted{
Pix: scaled,
Stride: m.Width * pixelsize,
Rect: bounds,
Palette: palette,
}
anim.Image = append(anim.Image, &img)
anim.Delay = append(anim.Delay, delay)
}
var buf bytes.Buffer
if err := gifencoder.EncodeAll(&buf, anim); err != nil {
c.Errorf("can't encode gif: %v", err)
return nil, err
}
if appengine.IsDevAppServer() {
// Validate gif by decoding it
r := bytes.NewReader(buf.Bytes())
size := r.Len()
if _, err := gif.DecodeAll(r); err != nil {
remaining := r.Len()
offset := size - remaining
c.Errorf("created an invalid gif: %v", err)
c.Errorf("error at offset %v (%x)", offset, offset)
}
}
return buf.Bytes(), nil
}
func (gs *GIFSpark) MakeGif() error {
g := new(gif.GIF)
for l := 0; l <= 100; l++ {
frame := gs.makeFrame(l)
g.Image = append(g.Image, frame)
g.Delay = append(g.Delay, 0)
}
return
}
// Generate writes to outFile an animated GIF
func (g *GifGenerator) Generate(input string, output string) (err error) {
// virtual terminal
var state = terminal.State{}
vt, err := terminal.Create(&state, ioutil.NopCloser(bytes.NewBuffer([]byte{})))
if err != nil {
return
}
defer vt.Close()
vt.Resize(g.Col, g.Row)
// play and capture
var (
images []*image.Paletted
delays []int
)
err = g.TtyPlay(input, vt, func(diff int32) (err error) {
delay := int(float64(diff)/g.Speed) / 10000
if delay > 0 {
var img *image.Paletted
img, err = g.Capture(&state)
if err != nil {
return
}
images = append(images, img)
delays = append(delays, delay)
}
return nil
})
if err != nil {
return
}
// generate gif file
outFile, err := os.Create(output)
if err != nil {
return
}
defer outFile.Close()
opts := gif.GIF{
Image: images,
Delay: delays,
}
if g.NoLoop {
opts.LoopCount = 1
}
err = gif.EncodeAll(outFile, &opts)
if err != nil {
return
}
return nil
}
func main() {
args := os.Args[1:]
if len(args) > 2 || len(args) == 0 {
showUsage()
return
}
input := args[0]
fmt.Println("Reading file", input)
file, err := os.Open(input)
if err != nil {
fmt.Println(err)
return
}
img, err := gif.DecodeAll(file)
if err != nil {
fmt.Println(err)
return
}
reversed := new(gif.GIF)
reversed.Delay = img.Delay
reversed.LoopCount = img.LoopCount
reversed.Image = reverse(img.Image)
fmt.Println("Reversing..")
var output string
if len(args) == 2 {
output = strings.TrimSuffix(args[1], filepath.Ext(input)) + ".gif"
} else {
output = strings.TrimSuffix(input, filepath.Ext(input)) + "_reversed.gif"
}
result, err := os.Create(output)
if err != nil {
fmt.Println(err)
return
}
gif.EncodeAll(result, reversed)
fmt.Println("✓ Saved", output)
}
func lissajous(out io.Writer, arr map[string]int) {
var (
cycles = 5
res = 0.001
size = 200
nframes = 64
delay = 8
)
if arr["cycles"] > 0 {
cycles = arr["cycles"]
}
if arr["res"] > 0 {
res = float64(arr["res"])
}
if arr["size"] > 0 {
size = arr["size"]
}
if arr["nframes"] > 0 {
nframes = arr["nframes"]
}
if arr["delay"] > 0 {
delay = arr["delay"]
}
freq := rand.Float64() * 3.0
anim := gif.GIF{LoopCount: nframes}
phase := 0.0
for i := 0; i < nframes; i++ {
colorIndex := uint8(blackIndex)
switch {
case i%9 <= 2:
colorIndex = greenIndex
case i%9 >= 3 && i%9 <= 5:
colorIndex = redIndex
case i%9 >= 6 && i%9 <= 8:
colorIndex = blueIndex
}
rect := image.Rect(0, 0, 2*size+1, 2*size+1)
img := image.NewPaletted(rect, palette)
for t := 0.0; t < float64(cycles)*2*math.Pi; t += res {
x := math.Sin(t)
y := math.Sin(t*freq + phase)
img.SetColorIndex(size+int(x*float64(size)+0.5), size+int(y*float64(size)+0.5), colorIndex)
}
phase += 0.1
anim.Delay = append(anim.Delay, delay)
anim.Image = append(anim.Image, img)
}
gif.EncodeAll(out, &anim)
}
func main() {
dir, _ := ioutil.ReadDir(".")
var imgs []*image.Paletted
for _, file := range dir {
f, _ := os.Open(file.Name())
defer f.Close()
if ext := path.Ext(file.Name()); ext != ".jpg" && ext != ".JPG" && ext != ".jpeg" && ext != ".png" {
fmt.Printf("File not an image: %s\n", file.Name())
} else {
img, err := rs.ResizePixels(f, 400, 400)
if err != nil {
fmt.Println(err)
}
var opt gif.Options
opt.NumColors = 256
buf := new(bytes.Buffer)
gif.Encode(buf, img, &opt)
g, _ := gif.DecodeAll(buf)
imgs = append(imgs, g.Image[0])
}
}
g := new(gif.GIF)
g.Image = imgs
g.Delay = evenDelay(100, len(g.Image))
g.LoopCount = 1000
var opt gif.Options
opt.NumColors = 256
out, err := os.Create("./output.gif")
if err != nil {
fmt.Println(err)
os.Exit(1)
}
err = gif.EncodeAll(out, g)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
fmt.Println("Generated image to output.gif \n")
}