Golang Floor示例

说明

golang floor示例是从最受好评的开源项目中提取的实现代码,你可以参考下面示例的使用方式。

编程语言: Golang

命名空间/包名称: math

示例#1
文件: matrixoperations.go 项目: ergenekonyigit/Numerical-Analysis-Examples

func main() {
	a := make([][]float64, size*size)
	b := make([][]float64, size*size)
	c := make([][]float64, size*size)
	for j := 0; j < size; j++ {
		a[j] = make([]float64, size)
		b[j] = make([]float64, size)
		c[j] = make([]float64, size)
	}

	for i := 0; i < size; i++ {
		for j := 0; j < size; j++ {
			a[i][j] = math.Floor(10 * rand.Float64())
			b[i][j] = math.Floor(10 * rand.Float64())
		}
	}

	print(a)
	fmt.Println(determinant(a))
	fmt.Printf("\n")
	print(b)
	c = addition(a, b)
	print(c)
	c = multiplication(a, b)
	print(c)
	c = transpose(c)
	print(c)
}

示例#2
文件: catlightd.go 项目: studentkittens/catlight

func (effect *FadeEffect) ComposeEffect() chan SimpleColor {
	c := make(chan SimpleColor, 1)

	keepLooping := false
	if effect.Repeat < 0 {
		keepLooping = true
	}

	max := max(effect.Color.R, effect.Color.B, effect.Color.G)
	go func() {
		for {

			if effect.Repeat <= 0 && !keepLooping {
				break
			}

			r := int(math.Floor(float64(effect.Color.R) / float64(max) * 100.0))
			g := int(math.Floor(float64(effect.Color.G) / float64(max) * 100.0))
			b := int(math.Floor(float64(effect.Color.B) / float64(max) * 100.0))

			for i := 0; i < int(max); i += 1 {
				c <- SimpleColor{uint8((i * r) / 100), uint8((i * g) / 100), uint8((i * b) / 100)}
				time.Sleep(effect.Delay)
			}

			for i := int(max - 1); i >= 0; i -= 1 {
				c <- SimpleColor{uint8((i * r) / 100), uint8((i * g) / 100), uint8((i * b) / 100)}
				time.Sleep(effect.Delay)
			}
			effect.Repeat--
		}
		close(c)
	}()
	return c
}

示例#3
文件: Vector3.go 项目: uzudil/three.go

func (v3 *Vector3) Floor() *Vector3 {
	v3.X = math.Floor(v3.X)
	v3.Y = math.Floor(v3.Y)
	v3.Z = math.Floor(v3.Z)

	return v3
}

示例#4
文件: quantile.go 项目: tsenart/quantile

// Get finds a value within (quantile - tolerance) * n <= value <= (quantile + tolerance) * n
// or 0 if no values have been observed.
func (est *Estimator) Get(quantile float64) float64 {
	if est.observations == 0 {
		return 0
	}

	est.flush()

	cur := est.head
	if cur == nil {
		return 0
	}

	midrank := math.Floor(quantile * est.observations)
	maxrank := midrank + math.Floor(est.invariant(midrank, est.observations)/2)

	rank := 0.0
	for cur.next != nil {
		rank += cur.rank
		if rank+cur.next.rank+cur.next.delta > maxrank {
			return cur.v
		}
		cur = cur.next
	}
	return cur.v
}

示例#5
文件: path.go 项目: thomaspeugeot/go.geo

// Encode converts the path to a string using the Google Maps Polyline Encoding method.
// Factor defaults to 1.0e5, the same used by Google for polyline encoding.
func (p *Path) Encode(factor ...int) string {
	f := 1.0e5
	if len(factor) != 0 {
		f = float64(factor[0])
	}

	var pLat int
	var pLng int

	var result bytes.Buffer
	scratch1 := make([]byte, 0, 50)
	scratch2 := make([]byte, 0, 50)

	for _, p := range p.PointSet {
		lat5 := int(math.Floor(p.Lat()*f + 0.5))
		lng5 := int(math.Floor(p.Lng()*f + 0.5))

		deltaLat := lat5 - pLat
		deltaLng := lng5 - pLng

		pLat = lat5
		pLng = lng5

		result.Write(append(encodeSignedNumber(deltaLat, scratch1), encodeSignedNumber(deltaLng, scratch2)...))

		scratch1 = scratch1[:0]
		scratch2 = scratch2[:0]
	}

	return result.String()
}

示例#6
文件: GesturePane.go 项目: ninjasphere/sphere-go-led-controller

func (p *GesturePane) Render() (*image.RGBA, error) {
	img := image.NewRGBA(image.Rect(0, 0, 16, 16))

	if p.last != nil {

		x := math.Floor(float64(p.last.Position.X)/float64(0xffff)*float64(16)) + 0.5
		y := math.Floor(float64(p.last.Position.Y)/float64(0xffff)*float64(16)) + 0.5
		z := math.Floor(float64(p.last.Position.Z)/float64(0xffff)*float64(16)) + 0.5

		r, _ := colorful.Hex("#FF000")
		g, _ := colorful.Hex("#00FF00")
		b, _ := colorful.Hex("#0000FF")

		gc := draw2d.NewGraphicContext(img)

		gc.SetStrokeColor(r)
		gc.MoveTo(0, x)
		gc.LineTo(16, x)
		gc.Stroke()

		gc.SetStrokeColor(g)
		gc.MoveTo(y, 0)
		gc.LineTo(y, 16)
		gc.Stroke()

		gc.SetStrokeColor(b)
		gc.MoveTo(16-z, 0)
		gc.LineTo(16-z, 16)
		gc.Stroke()
	}

	return img, nil
}

示例#7
文件: color.go 项目: se77en/c6

func RGBColorDivNumber(c *ast.RGBColor, n *ast.Number) *ast.RGBColor {
	var val = n.Value
	var r = math.Floor(float64(c.R) / val)
	var g = math.Floor(float64(c.G) / val)
	var b = math.Floor(float64(c.B) / val)
	return ast.NewRGBColor(uint32(r), uint32(g), uint32(b), nil)
}

示例#8
文件: solution.go 项目: esix/competitive-programming

func main() {
	bi := bufio.NewReader(os.Stdin)
	bo := bufio.NewWriter(os.Stdout)
	defer bo.Flush()

	var p_fl, q_fl float64
	fmt.Fscan(bi, &p_fl, &q_fl)

	p := int64(math.Floor(p_fl*100.0 + .5))
	q := int64(math.Floor(q_fl*100.0 + .5))

	var k int64
	for k = 1; true; k++ {
		kk := 10000 * k
		pp := kk / p
		qq := kk / q
		if qq < pp {
			if kk%p == 0 && pp-qq == 1 {
				// special case: 10000 * k ~ p
			} else {
				break
			}
		}
	}

	fmt.Fprintln(bo, 10000*k/q+1)
}

示例#9
文件: entity.go 项目: Thinkofname/monstergame

func CheckCollision(pb *box, dx, dy float64) (col bool, nx, ny float64) {
	for x := int(math.Floor(pb.x/tileSize) - 1); x <= int(math.Ceil((pb.x+pb.w)/tileSize)+1); x++ {
		for y := int(math.Floor(pb.y/tileSize) - 1); y <= int(math.Ceil((pb.y+pb.h)/tileSize)+1); y++ {
			t := GetTile(x, y)
			if t.IsSolid() {
				b := &box{
					x: float64(x) * tileSize,
					y: float64(y) * tileSize,
					w: tileSize, h: tileSize,
				}
				if b.collides(pb) {
					col = true
					if dx < 0 {
						nx = b.x + b.w + 0.001
					} else if dx > 0 {
						nx = b.x - pb.w - 0.001
					}
					if dy < 0 {
						ny = b.y + b.h + 0.001
					} else if dy > 0 {
						ny = b.y - pb.h - 0.001
					}
					nx /= tileSize
					ny /= tileSize
					return
				}
			}
		}
	}
	return
}

示例#10
文件: trimmean.go 项目: muyiwaolurin/spreadsheet-functions

// TrimMean returns the mean of the interior of a supplied set of values
// Array  -	An array of numeric values, for which you want to calculate the trimmed mean
// Percent	-	The percentage of values that you want to be discarded from the supplied array
func TrimMean(percent float64, arrays ...float64) (float64, error) {

	// First find n = number of observations
	n := float64(len(arrays))

	// Reorder them as "order statistics" Xi from the smallest to the largest
	sort.Sort(SmallNums(arrays))

	if math.IsNaN(percent) {
		return 0.0, errors.New("#VALUE!	-	Occurred because the percent argument cannot be interpreted as a Numeric value")
	}

	// Find lower case p=P/100 = proportion trimmed
	p := percent / 100.00

	if p < 0 || p > 1 {
		return 0.0, errors.New("#NUM!, Occurred the supplied percent argument is < 0 or > 1")
	}

	// If np is an integer use k=np and trim k observations at both ends.
	k := math.Floor((n * p) / 2)

	//r = remaining observations = n−2k
	r := n - (2 * k)

	k = math.Floor(k)

	// Trimmed mean = (1/R)(Xk+1+Xk+2+…+Xn−k)
	sum := 0.0
	for i := int(k); i <= int(n-k-1); i++ {
		sum += arrays[i]
	}
	return (1 / r) * sum, nil
}

示例#11
文件: raster.go 项目: emicklei/zenna

func (g Raster) Accept(visitor Visitor) {
	c := new(Composite)
	hc := math.Floor(g.Width / g.Dx / 2)
	vc := math.Floor(g.Height / g.Dy / 2)
	hw := g.Width / 2
	hh := g.Height / 2
	if g.Dx != 0 {
		for i := -hc; i <= hc; i++ {
			x := i*g.Dx + g.Center.X
			segment := LineSegment{P(x, g.Center.Y-hh), P(x, g.Center.Y+hh)}
			c.Add(segment)
		}
	} else {
		segment := LineSegment{P(g.Center.X, g.Center.Y-hh), P(g.Center.X, g.Center.Y+hh)}
		c.Add(segment)
	}
	if g.Dy != 0 {
		for i := -vc; i <= vc; i++ {
			y := i*g.Dy + g.Center.Y
			segment := LineSegment{P(g.Center.X-hw, y), P(g.Center.X+hw, y)}
			c.Add(segment)
		}
	} else {
		segment := LineSegment{P(g.Center.X-hw, g.Center.Y), P(g.Center.X+hw, g.Center.Y)}
		c.Add(segment)
	}
	c.Accept(visitor)
}

示例#12
文件: clients.go 项目: dantoye/bots

func (e *Entity) Colliding() bool {
	playerSize := .5
	sx := int(math.Floor(e.x - playerSize/2))
	sy := int(math.Floor(e.y - playerSize/2))
	sz := int(math.Floor(e.z - playerSize/2))
	lx := int(math.Ceil(e.x + playerSize/2))
	ly := int(math.Ceil(e.y + playerSize/2))
	lz := int(math.Ceil(e.z + playerSize/2))
	if sx < 0 || lx >= worldW || sz < 0 || lz >= worldD {
		return true
	}
	if sy < 0 || ly >= worldH {
		return false
	}
	for ix := sx; ix < lx; ix += 1 {
		for iy := sy; iy < ly; iy += 1 {
			for iz := sz; iz < lz; iz += 1 {
				blockType := level[ix][iy][iz]
				if blockType > 0 {
					return true
				}
			}
		}
	}
	return false
}

示例#13
文件: square.go 项目: shitfSign/gowebimg

func square(im *webimg.Image, size int) error {
	im_cols, _ := webimg.Wi_get_cols(im)
	im_rows, _ := webimg.Wi_get_rows(im)

	var x, y, cols int

	if im_cols > im_rows {
		cols = im_rows
		y = 0
		x = int(math.Floor(float64(im_cols-im_rows) / 2.0))
	} else {
		cols = im_cols
		x = 0
		y = int(math.Floor(float64(im_rows-im_cols) / 2.0))
	}

	_, err := webimg.Wi_crop(im, x, y, cols, cols)
	if err != nil {
		return err
	}

	_, err = webimg.Wi_scale(im, size, 0)
	if err != nil {
		return err
	}
	return nil
}

示例#14
文件: main.go 项目: TheOnly92/gexic

func mouseButtonCallback(button, state int) {
	if currExX != -1 || currExY != -1 || mouseLock || len(selectedHex) < 3 {
		return
	}
	x, y := glfw.MousePos()

	if state == glfw.KeyPress {
		switch button {
		case glfw.MouseLeft:
			// fmt.Println(x, y)
			currExX = int(math.Floor((float64(x) - 80) / 33))
			currExY = int(math.Floor((float64(y) - 80 - 19) / 38))
			if currExX%2 == 1 {
				currExY = (y - 80) / 36
			}
			if currExX > 9 || currExY > 8 || currExX < 0 || currExY < 0 {
				currExX = -1
				currExY = -1
				return
			}
			if hexMap[currExX][currExY] == 6 && currExX > 0 && currExX < 9 && currExY > 0 && (currExX%2 == 0 && currExY < 7 || currExX%2 == 1 && currExY < 8) {
				starRotate = true
			}
			timesToRotate = 2
			mouseLock = true
			fmt.Println("Mouse locked")
			// fmt.Println(currExX, currExY)
			// renderHexMap(currExX, currExY)
		}
	}
}

示例#15
文件: plumb.go 项目: mrG7/escher

// AsInt accepts an int or float64 value and converts it to an int value.
func AsInt(v interface{}) int {
	switch t := v.(type) {
	case int:
		return t
	case float64:
		if math.Floor(t) == t {
			return int(t)
		}
		panic("precision")
	case complex128:
		if imag(t) != 0 {
			panic("imaginary integers")
		}
		f := real(t)
		if math.Floor(f) == f {
			return int(f)
		}
		panic("real precision")
	case string:
		i, err := strconv.Atoi(t)
		if err != nil {
			panic("illegible integer")
		}
		return i
	}
	panic(4)
}

示例#16
文件: summary.go 项目: npk/trailk

func (this *Summary) getCycleInfo(pTime time.Time) (*Cycle, error) {
	lengthSeconds := this.Length.Seconds()
	passedSeconds := pTime.Sub(this.Created).Seconds()

	if passedSeconds < 0 {
		return nil, ErrCycleTimeTooEarlier
	}

	periodsFloat := float64(this.Periods)

	periodLength := math.Ceil(lengthSeconds / periodsFloat)
	periodFloat := math.Floor(passedSeconds / periodLength)
	periodID := int64(periodFloat)

	resetFloat := int64(math.Floor(periodFloat / periodsFloat))

	segmentScrollID := periodID % int64(this.Periods)
	segmentID := resetFloat % int64(this.Reset)

	// Following result
	// Make sure all the number below is larger than 0
	return &Cycle{
		Period:   periodID + 1,
		Segments: segmentScrollID + 1,
		Segment:  segmentID + 1,
	}, nil
}

示例#17
文件: gogoogledm.go 项目: heetch/gogoogledm

func (api *DistanceMatrixAPI) groupCoordinates(origins []Coordinates, destinations []Coordinates, maxGroupSize int) (apiCalls []ApiCall) {
	if maxGroupSize == 1 {
		apiCalls = append(apiCalls, ApiCall{origins, destinations})
		return apiCalls
	}

	destinationsSize := len(destinations)
	originsSize := len(origins)

	if destinationsSize > originsSize {
		//Split destinations
		maxBlockSize := math.Floor(float64(destinationsSize) / float64(maxGroupSize))
		blocks := splitSliceIntoBlocks(destinations, int(maxBlockSize))

		for _, b := range blocks {
			apiCalls = append(apiCalls, ApiCall{
				Origins:      origins,
				Destinations: b,
			})
		}
	} else {
		//Split origins
		maxBlockSize := math.Floor(float64(originsSize) / float64(maxGroupSize))
		blocks := splitSliceIntoBlocks(origins, int(maxBlockSize))

		for _, o := range blocks {
			apiCalls = append(apiCalls, ApiCall{
				Origins:      o,
				Destinations: destinations,
			})
		}
	}

	return apiCalls
}

示例#18
文件: resample.go 项目: hamstah/imaging

// fast nearest-neighbor resize, no filtering
func resizeNearest(src *image.NRGBA, width, height int) *image.NRGBA {
	dstW, dstH := width, height

	srcBounds := src.Bounds()
	srcW := srcBounds.Max.X
	srcH := srcBounds.Max.Y

	dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))

	dx := float64(srcW) / float64(dstW)
	dy := float64(srcH) / float64(dstH)

	Parallel(dstH, func(partStart, partEnd int) {

		for dstY := partStart; dstY < partEnd; dstY++ {
			fy := (float64(dstY)+0.5)*dy - 0.5

			for dstX := 0; dstX < dstW; dstX++ {
				fx := (float64(dstX)+0.5)*dx - 0.5

				srcX := int(math.Min(math.Max(math.Floor(fx+0.5), 0.0), float64(srcW)))
				srcY := int(math.Min(math.Max(math.Floor(fy+0.5), 0.0), float64(srcH)))

				srcOff := srcY*src.Stride + srcX*4
				dstOff := dstY*dst.Stride + dstX*4

				copy(dst.Pix[dstOff:dstOff+4], src.Pix[srcOff:srcOff+4])
			}
		}

	})

	return dst
}

示例#19
文件: color.go 项目: se77en/c6

func HexColorDivNumber(color *ast.HexColor, num *ast.Number) *ast.HexColor {
	r := uint32(math.Floor(float64(color.R) / num.Value))
	g := uint32(math.Floor(float64(color.G) / num.Value))
	b := uint32(math.Floor(float64(color.B) / num.Value))
	hex := ast.Hex(fmt.Sprintf("#%02X%02X%02X", r, g, b))
	return &ast.HexColor{hex, r, g, b, nil}
}

示例#20
文件: util.go 项目: samlecuyer/ecumene

func Deg2num(lng, lat float64, zoom int) (x, y int) {
	n := math.Exp2(float64(zoom))
	x = int(math.Floor((lng + 180.0) / 360.0 * n))
	lat_rad := lat * math.Pi / 180
	y = int(math.Floor((1.0 - math.Log(math.Tan(lat_rad)+1.0/math.Cos(lat_rad))/math.Pi) / 2.0 * n))
	return
}

示例#21
文件: goship.go 项目: johnzan/goship

func formatTime(t time.Time) string {
	s := time.Since(t)
	switch {
	case s.Seconds() < 60:
		f := "second"
		if math.Floor(s.Seconds()) > 1 {
			f += "s"
		}
		return fmt.Sprintf("%d "+f+" ago", int(s.Seconds()))
	case s.Minutes() < 60:
		f := "minute"
		if math.Floor(s.Minutes()) > 1 {
			f += "s"
		}
		return fmt.Sprintf("%d "+f+" ago", int(s.Minutes()))
	case s.Hours() < 24:
		f := "hour"
		if math.Floor(s.Hours()) > 1 {
			f += "s"
		}
		return fmt.Sprintf("%d "+f+" ago", int(s.Hours()))
	default:
		layout := "Jan 2, 2006 at 3:04pm (MST)"
		return t.Format(layout)
	}
}

示例#22
文件: base62.go 项目: henrylee2cn/short

func EncodeInt(value int64) string {
	var output string
	var remainder int64
	var numberOfCycles int64

	base := int64(62)
	remainder = value % base
	output = encodeStd2[remainder]
	numberOfCycles = int64(math.Floor(float64(value/base))) - 1

	if numberOfCycles >= 0 && numberOfCycles < 62 {
		output = strings.Join([]string{encodeStd2[numberOfCycles], output}, "")
	}

	for i := 0; i < 10; i++ {
		if numberOfCycles < 62 {
			break
		}
		i = 0
		remainder = numberOfCycles % base

		numberOfCycles = int64(math.Floor(float64(numberOfCycles/base))) - 1
		output = strings.Join([]string{encodeStd2[remainder], output}, "")
		if numberOfCycles <= 0 {
			i = 10
		}
	}
	return output
}

示例#23
文件: types.go 项目: valtyr/chunkymonkey

func (p *AbsXyz) ToBlockXyz() *BlockXyz {
	return &BlockXyz{
		BlockCoord(math.Floor(float64(p.X))),
		BlockYCoord(math.Floor(float64(p.Y))),
		BlockCoord(math.Floor(float64(p.Z))),
	}
}

示例#24
文件: problem64.go 项目: mjwestcott/projecteuler

func continuedFracSqrt(S float64) []int {
	// https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Continued_fraction_expansion
	// Using variables S, m, d, a as in the URL above.
	m := 0.0
	d := 1.0
	a := math.Floor(math.Sqrt(S))
	result := []int{}
	seen := make(map[string]bool)
	for {
		seen[k([]float64{m, d, a})] = true
		result = append(result, int(a))

		m = (d * a) - m
		d = (S - math.Pow(m, 2.0)) / d
		if d == 0 {
			// S is a perfect square.
			return result
		}
		a = math.Floor((math.Floor(math.Sqrt(S)) + m) / d)

		// The algorithm terminates when [m d a] repeats.
		if seen[k([]float64{m, d, a})] {
			return result
		}
	}

}

示例#25
文件: coreutils.go 项目: cgrates/cgrates

// Round return rounded version of x with prec precision.
//
// Special cases are:
//	Round(±0) = ±0
//	Round(±Inf) = ±Inf
//	Round(NaN) = NaN
func Round(x float64, prec int, method string) float64 {
	var rounder float64
	maxPrec := 7 // define a max precison to cut float errors
	if maxPrec < prec {
		maxPrec = prec
	}
	pow := math.Pow(10, float64(prec))
	intermed := x * pow
	_, frac := math.Modf(intermed)

	switch method {
	case ROUNDING_UP:
		if frac >= math.Pow10(-maxPrec) { // Max precision we go, rest is float chaos
			rounder = math.Ceil(intermed)
		} else {
			rounder = math.Floor(intermed)
		}
	case ROUNDING_DOWN:
		rounder = math.Floor(intermed)
	case ROUNDING_MIDDLE:
		if frac >= 0.5 {
			rounder = math.Ceil(intermed)
		} else {
			rounder = math.Floor(intermed)
		}
	default:
		rounder = intermed
	}

	return rounder / pow
}

示例#26
文件: arb_image.go 项目: jwohlwend/dvid

// NewArbSlice returns an image with arbitrary 3D orientation.
// The 3d points are in real world space definited by resolution, e.g., nanometer space.
func (d *Data) NewArbSlice(topLeft, topRight, bottomLeft dvid.Vector3d, res float64) (*ArbSlice, error) {
	// Compute the increments in x,y and number of pixes in each direction.
	dx := topRight.Distance(topLeft)
	dy := bottomLeft.Distance(topLeft)
	nxFloat := math.Floor(dx / res)
	nyFloat := math.Floor(dy / res)
	incrX := topRight.Subtract(topLeft).DivideScalar(nxFloat)
	incrY := bottomLeft.Subtract(topLeft).DivideScalar(nyFloat)
	size := dvid.Point2d{int32(nxFloat) + 1, int32(nyFloat) + 1}
	bytesPerVoxel := d.Properties.Values.BytesPerElement()
	arb := &ArbSlice{topLeft, topRight, bottomLeft, res, size, incrX, incrY, bytesPerVoxel, nil}

	// Allocate the image buffer
	numVoxels := size[0] * size[1]
	if numVoxels <= 0 {
		return nil, fmt.Errorf("Bad arbitrary image size requested: %s", arb)
	}
	requestSize := int64(bytesPerVoxel) * int64(numVoxels)
	if requestSize > server.MaxDataRequest {
		return nil, fmt.Errorf("Requested payload (%d bytes) exceeds this DVID server's set limit (%d)",
			requestSize, server.MaxDataRequest)
	}
	arb.data = make([]byte, requestSize)
	return arb, nil
}

示例#27
文件: main.go 项目: Ganners/gorender

// Small test program to get things running
func main() {
	window := window.NewWindow("My Application", 800, 600)

	// Create window to draw on
	window.Create()
	defer window.Destroy()

	// Calculate midpoints
	midX := math.Floor(float64(window.Width) / 2.0)
	midY := math.Floor(float64(window.Height) / 2.0)

	maxRadius := math.Min(float64(window.Height), float64(window.Width))

	for frame := 0.0; ; frame++ {

		window.Backbuffer.Fill(0xFF000000)
		radius := float64(int(frame)%int(maxRadius)) / 2.0

		// Draw something weird on-screen
		for i := 0.0; i < 5.0; i++ {
			for theta := 0.0; theta < 2.0*math.Pi; theta += 0.005 {

				y := int(math.Floor(midY - (radius-(i+theta*20.0))*math.Sin(theta*i+(frame))))
				x := int(math.Floor(midX - (radius-(i+theta*50.0))*math.Cos(theta*i+(frame))))

				window.Backbuffer.DrawPixel(
					x, y, uint32(0xFF0000FF)|((uint32(frame)%255)<<8))
			}
			window.Update()
		}
		time.Sleep(time.Millisecond * (1000 / 30))
	}
}

示例#28
文件: resize.go 项目: slav123/bimg

func imageCalculations(o *Options, inWidth, inHeight int) float64 {
	factor := 1.0
	xfactor := float64(inWidth) / float64(o.Width)
	yfactor := float64(inHeight) / float64(o.Height)

	switch {
	// Fixed width and height
	case o.Width > 0 && o.Height > 0:
		if o.Crop {
			factor = math.Min(xfactor, yfactor)
		} else {
			factor = math.Max(xfactor, yfactor)
		}
	// Fixed width, auto height
	case o.Width > 0:
		factor = xfactor
		o.Height = int(math.Floor(float64(inHeight) / factor))
	// Fixed height, auto width
	case o.Height > 0:
		factor = yfactor
		o.Width = int(math.Floor(float64(inWidth) / factor))
	// Identity transform
	default:
		o.Width = inWidth
		o.Height = inHeight
		break
	}

	return factor
}

示例#29
文件: main.go 项目: dlwr/copyright-protector

func glitchImage(wand *imagick.MagickWand, q url.Values) ([]byte, error) {
	data := wand.GetImage().GetImageBlob()
	jpgHeaderLength := getJpegHeaderSize(data)
	maxIndex := len(data) - jpgHeaderLength - 4
	params := getParams(q)
	length := int(params["iterations"])
	for i := 0; i < length; i++ {
		pxMin := math.Floor(float64(maxIndex) / params["iterations"] * float64(i))
		pxMax := math.Floor(float64(maxIndex) / params["iterations"] * float64((i + 1)))
		delta := pxMax - pxMin
		pxI := math.Floor(pxMin + delta*params["seed"])
		if int(pxI) > maxIndex {
			pxI = float64(maxIndex)
		}
		index := math.Floor(float64(jpgHeaderLength) + pxI)
		data[int(index)] = byte(math.Floor(params["amount"] * float64(256)))
	}
	wand2 := imagick.NewMagickWand()
	if err := wand2.ReadImageBlob(data); err != nil {
		return nil, err
	}
	if err := wand2.SetImageFormat("PNG"); err != nil {
		return nil, err
	}
	return wand2.GetImage().GetImageBlob(), nil
}

示例#30
文件: face.go 项目: berak/go-faces

// as reference, this is similar to the opencv one
// Sampler
func elbp(m *Matrix, pos, radius int) (way uint8) {
	way = 0
	cen := m.e[pos]
	for n := uint8(0); n < 8; n++ {
		x := float64(-radius) * math.Sin(math.Pi*float64(n)/4.0)
		y := float64(radius) * math.Cos(math.Pi*float64(n)/4.0)
		fx := math.Floor(x)
		fy := math.Floor(y)
		cx := math.Ceil(x)
		cy := math.Ceil(y)
		// fractional part
		ty := y - fy
		tx := x - fx
		// set interpolation weights
		w1 := (1.0 - tx) * (1.0 - ty)
		w2 := tx * (1.0 - ty)
		w3 := (1.0 - tx) * ty
		w4 := tx * ty
		t := w1 * float64(m.e[pos+int(fx)+int(fy)*m.w])
		t += w2 * float64(m.e[pos+int(cx)+int(fy)*m.w])
		t += w3 * float64(m.e[pos+int(fx)+int(cy)*m.w])
		t += w4 * float64(m.e[pos+int(cx)+int(cy)*m.w])
		if uint8(t) > cen {
			way |= 1 << n
		}
	}
	return
}

展开阅读全文