Exemple #1
0
func (o *drawing) Putchar(ch byte) {
	o.init()
	start := int(ch) - 32
	if start < 0 || start > 96 {
		start = 3
	}
	start *= 5
	for i := 0; i < 5; i++ {
		for j := 0; j < 7; j++ {
			x, y := o.px+float64(i)*SPOTSIZE, o.py-float64(j)*SPOTSIZE
			var c byte = 0 // 50
			if ((basic.Font[start+i] >> uint(j)) & 1) != 0 {
				c = 255 // 250
			}
			o.canvas.PaintTriangle(int(x/100.0*WIDTH), int(y/100.0*HEIGHT),
				int((x+SPOTSIZE)/100.0*WIDTH), int(y/100.0*HEIGHT),
				int(x/100.0*WIDTH), int((y+SPOTSIZE)/100.0*HEIGHT),
				canvas.RGB(c, c, c))
		}
	}
	o.px += SPOTSIZE * 7
	if o.px > 100-MARGIN {
		o.px = MARGIN
		o.py -= SPOTSIZE * 10
		if o.py < MARGIN {
			o.py = 100 - MARGIN
		}
	}
}
Exemple #2
0
func (o *drawing) fonttest(t *basic.Terp, _ []float64) float64 {
	o.init()
	x0, y0 := 5.0, 98.0
	for i := 0; i < len(basic.Font); i++ {
		for j := 0; j < 8; j++ {
			x, y := x0+float64(i), y0-float64(j)

			var c byte = 50
			if ((basic.Font[i] >> uint(j)) & 1) == 1 {
				c = 250
			}
			o.canvas.PaintTriangle(int(x/100.0*0.5*WIDTH), int(y/100.0*0.5*HEIGHT),
				int((x+1)/100.0*0.5*WIDTH), int(y/100.0*0.5*HEIGHT),
				int(x/100.0*0.5*WIDTH), int((y+1)/100.0*0.5*HEIGHT),
				canvas.RGB(c/5, c, c/5))
		}
		if i%5 == 4 {
			x0 += 1
		}
		if i%60 == 59 {
			x0, y0 = 5-float64(i), y0-10
		}
	}
	return 0.0
}
Exemple #3
0
func main() {
	flag.Parse()

	// Special -l list command.
	if *list {
		for k, v := range superfractal.Builtin {
			Printf("%s\t%s\n", k, v)
		}
		return
	}

	c := canvas.NewCanvas(*width, *height)
	if *grid {
		c.Grid(*width/10, canvas.RGB(100, 100, 100))
	}
	ifs := superfractal.ParseIfsParams(*params)
	switch *style {
	case 1: // Whole.
		c.Fill(0, 0, *width, *height, canvas.Blue)
		// c.WritePng(os.Stdout)
		// return
		c = ifs.WholeGame(c, *num)
	case 0: // Chaos.
		ifs.ChaosGame(c, *num, canvas.Green)
	}
	c.WritePng(os.Stdout)
}
Exemple #4
0
func (o *drawing) point(t *basic.Terp, args []float64) float64 {
	o.init()
	var r, g, b byte // Default is black.
	if len(args) > 2 {
		r, g, b = Decimal2RGB(args[2]) // Use given color.
	}
	o.canvas.Set(int(args[0]/100*WIDTH), int(args[1]/100*HEIGHT), canvas.RGB(r, g, b))
	return 0
}
Exemple #5
0
func (o *drawing) clear(t *basic.Terp, args []float64) float64 {
	o.init()
	var r, g, b byte // Default is black.
	if len(args) > 0 {
		r, g, b = Decimal2RGB(args[0]) // Use given color.
	}
	o.canvas.Fill(0, 0, WIDTH, HEIGHT, canvas.RGB(r, g, b))
	return 0
}
Exemple #6
0
func (o *drawing) triangle(t *basic.Terp, args []float64) float64 {
	o.init()
	var r, g, b byte // Default is black.
	if len(args) > 6 {
		r, g, b = Decimal2RGB(args[6]) // Use given color.
	}
	o.canvas.PaintTriangle(int(args[0]/100.0*WIDTH), int(args[1]/100.0*HEIGHT),
		int(args[2]/100.0*WIDTH), int(args[3]/100.0*HEIGHT),
		int(args[4]/100.0*WIDTH), int(args[5]/100.0*HEIGHT),
		canvas.RGB(r, g, b))
	return 0
}
Exemple #7
0
func main() {
	flag.Parse()

	// Special -l list command, listing short names for builtin IFSs.
	if *list {
		for k, v := range superfractal.Builtin {
			Printf("%s\t%s\n", k, v)
		}
		return
	}

	// Parse IFSs & construct initial Triptych.
	ifss := superfractal.ParseListOfIfsParams(*params)
	src := superfractal.NewTriptych(*numPanels, *width, *height)

	if *startTriang {
		// Special hack for demoing sier's traingles
		for i := 0; i < *numPanels; i++ {
			src.Panels[i].PaintTriangle(0, 0, 0, *height, *width, 0, canvas.White)
		}
	} else {
		// Fill initial Triptych with different colors.
		r, g, b := byte(255), byte(0), byte(0)
		for i := 0; i < *numPanels; i++ {
			if *mustWhite {
				r, g, b = byte(255), byte(255), byte(255)
			}
			src.Panels[i].Fill(0, 0, *width, *height, canvas.RGB(r, g, b))

			// Rotate & dim the colors a bit, on each iteration.
			// TODO: something better than this.
			r, g, b = byte(0.96*float64(b)), byte(0.96*float64(r)), byte(0.96*float64(g))
		}
	}

	// Loop for *num steps, creating successive superfractal approximations.
	for i := 0; i < *num; i++ {
		targ := superfractal.NewTriptych(*numPanels, *width, *height)
		targ.SuperStep(src, ifss)

		for j := 0; j < *numPanels; j++ {
			filename := Sprintf("%s.%03d.%03d.png", *base, i, j)
			canvas.Say(filename)
			f, err := os.Create(filename)
			if err != nil {
				panic(err)
			}
			targ.Panels[j].WritePng(f)
			f.Close()
		}
		src = targ
	}
}
Exemple #8
0
// MapImageTo maps one picture through an IFS onto another.
func (o Affine) MapImageTo(src *canvas.Canvas, dest *canvas.Canvas, k int, done chan int) {
	for i := 0; i < src.Width; i++ {
		x := float64(i) / src.FWidth
		for j := 0; j < src.Height; j++ {
			r, g, b := src.Get(i, j)
			if r > 0 || g > 0 || b > 0 {
				y := float64(j) / src.FHeight
				x2, y2 := o.Apply(x, y)
				dest.FSet(x2, y2, canvas.RGB(r, g, b))
			}
		}
	}
	done <- k
}
func (h H) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	// fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
	strs := notnum.Split(r.URL.Path, -1)
	var nums []float64
	for _, s := range strs {
		if s == "" {
			continue
		}
		f, err := strconv.ParseFloat(s, 64)
		if err != nil {
			panic(err)
		}
		nums = append(nums, f)
	}

	can := canvas.NewCanvas(*WIDTH, *HEIGHT)
	can.Grid(50, canvas.RGB(20, 20, 20))

	for i := 0; i < len(nums)-8; i += 9 {
		x1 := int(nums[i+0])
		y1 := int(nums[i+1])
		x2 := int(nums[i+2])
		y2 := int(nums[i+3])
		x3 := int(nums[i+4])
		y3 := int(nums[i+5])

		red := byte(nums[i+6])
		green := byte(nums[i+7])
		blue := byte(nums[i+8])

		can.PaintTriangle(x1, y1, x2, y2, x3, y3, canvas.RGB(red, green, blue))
	}

	w.Header().Set("Content-Type", "image/png")
	can.WritePng(w)
}