func ProcessRoi(img *opencv.IplImage, gradeOfCanny int) *opencv.IplImage {

	var roi = img.GetROI()

	w := roi.Width()
	h := roi.Height()

	// Create the output image
	cedge := opencv.CreateImage(w, h, opencv.IPL_DEPTH_8U, 3)
	//defer cedge.Release()

	// Convert to grayscale
	gray := opencv.CreateImage(w, h, opencv.IPL_DEPTH_8U, 1)
	edge := opencv.CreateImage(w, h, opencv.IPL_DEPTH_8U, 1)
	//newimage := opencv.CreateImage(w, h, opencv.IPL_DEPTH_8U, 1)
	defer gray.Release()
	defer edge.Release()

	opencv.CvtColor(img, gray, opencv.CV_BGR2GRAY)

	opencv.Smooth(gray, edge, opencv.CV_BLUR, 3, 3, 0, 0)
	opencv.Not(gray, edge)

	// Run the edge detector on grayscale
	opencv.Canny(gray, edge, float64(gradeOfCanny), float64(gradeOfCanny*3), 3)

	opencv.Zero(cedge)
	// copy edge points
	opencv.Copy(img, cedge, edge)

	return cedge

}
Example #2
0
func ProcessImage(img *opencv.IplImage, win *opencv.Window, pos int) error {
	w := img.Width()
	h := img.Height()

	// Create the output image
	cedge := opencv.CreateImage(w, h, opencv.IPL_DEPTH_8U, 3)
	defer cedge.Release()

	// Convert to grayscale
	gray := opencv.CreateImage(w, h, opencv.IPL_DEPTH_8U, 1)
	edge := opencv.CreateImage(w, h, opencv.IPL_DEPTH_8U, 1)
	defer gray.Release()
	defer edge.Release()

	opencv.CvtColor(img, gray, opencv.CV_BGR2GRAY)

	opencv.Smooth(gray, edge, opencv.CV_BLUR, 3, 3, 0, 0)
	opencv.Not(gray, edge)

	// Run the edge detector on grayscale
	opencv.Canny(gray, edge, float64(pos), float64(pos*3), 3)

	opencv.Zero(cedge)
	// copy edge points
	opencv.Copy(img, cedge, edge)

	win.ShowImage(img)
	return nil
}
Example #3
0
func main() {
	_, currentfile, _, _ := runtime.Caller(0)
	cascade := path.Join(path.Dir(currentfile), "haarcascade_frontalface_alt.xml")

	window := opencv.NewWindowDriver()
	camera := opencv.NewCameraDriver(0)

	work := func() {
		var image *cv.IplImage

		camera.On(opencv.Frame, func(data interface{}) {
			image = data.(*cv.IplImage)
		})

		gobot.Every(500*time.Millisecond, func() {
			if image != nil {
				i := image.Clone()
				faces := opencv.DetectFaces(cascade, i)
				i = opencv.DrawRectangles(i, faces, 0, 255, 0, 5)
				window.ShowImage(i)
			}

		})
	}

	robot := gobot.NewRobot("faceBot",
		[]gobot.Connection{},
		[]gobot.Device{window, camera},
		work,
	)

	robot.Start()
}
Example #4
0
func ToByteBuffer(image *opencv.IplImage) []byte {

	buf := new(bytes.Buffer)

	err := jpeg.Encode(buf, image.ToImage(), nil)
	if err != nil {
		panic(err)
	}
	return buf.Bytes()
}
Example #5
0
func (detector *FaceDetector) DetectGlasses(image *opencv.IplImage, roi pixelArea) (leftEyes, rightEyes pixelCoords) {

	var topFace opencv.Rect
	var eyes pixelCoords

	topFace.Init(roi.X(), roi.Y()+int(float64(roi.Height())*0.20), roi.Width(), int(float64(roi.Height())/2))

	image.SetROI(topFace)
	for _, eye := range detector.glassesCascade.DetectObjects(image) {
		leftEyes = append(leftEyes, pixelCoord{
			x:      eye.X() + topFaceLeft.X(),
			y:      eye.Y() + topFaceLeft.Y(),
			width:  eye.Width(),
			height: eye.Height(),
		})
	}

	fmt.Println(len(leftEyes), " left eyes found")

	image.SetROI(topFaceRight)
	for _, eye := range detector.glassesCascade.DetectObjects(image) {
		rightEyes = append(rightEyes, pixelCoord{
			x:      eye.X() + topFaceRight.X(),
			y:      eye.Y() + topFaceRight.Y(),
			width:  eye.Width(),
			height: eye.Height(),
		})
	}
	fmt.Println(len(rightEyes), " right eyes found")

	image.ResetROI()
	return
}
func main() {
	runtime.GOMAXPROCS(runtime.NumCPU())

	_, currentfile, _, _ := runtime.Caller(0)
	cascade := path.Join(path.Dir(currentfile), "haarcascade_frontalface_alt.xml")
	window := opencv.NewWindowDriver()
	camera := opencv.NewCameraDriver("tcp://192.168.1.1:5555")
	ardroneAdaptor := ardrone.NewAdaptor()
	drone := ardrone.NewDriver(ardroneAdaptor)

	work := func() {
		detect := false
		drone.TakeOff()
		var image *cv.IplImage
		camera.On(opencv.Frame, func(data interface{}) {
			image = data.(*cv.IplImage)
			if !detect {
				window.ShowImage(image)
			}
		})
		drone.On(ardrone.Flying, func(data interface{}) {
			gobot.After(1*time.Second, func() { drone.Up(0.2) })
			gobot.After(2*time.Second, func() { drone.Hover() })
			gobot.After(5*time.Second, func() {
				detect = true
				gobot.Every(300*time.Millisecond, func() {
					drone.Hover()
					i := image
					faces := opencv.DetectFaces(cascade, i)
					biggest := 0
					var face *cv.Rect
					for _, f := range faces {
						if f.Width() > biggest {
							biggest = f.Width()
							face = f
						}
					}
					if face != nil {
						opencv.DrawRectangles(i, []*cv.Rect{face}, 0, 255, 0, 5)
						centerX := float64(image.Width()) * 0.5
						turn := -(float64(face.X()) - centerX) / centerX
						fmt.Println("turning:", turn)
						if turn < 0 {
							drone.Clockwise(math.Abs(turn * 0.4))
						} else {
							drone.CounterClockwise(math.Abs(turn * 0.4))
						}
					}
					window.ShowImage(i)
				})
				gobot.After(20*time.Second, func() { drone.Land() })
			})
		})
	}

	robot := gobot.NewRobot("face",
		[]gobot.Connection{ardroneAdaptor},
		[]gobot.Device{window, camera, drone},
		work,
	)

	robot.Start()
}
Example #7
0
func (detector *FaceDetector) DetectFacialFeatures(image *opencv.IplImage, faceCoords []pixelCoord) faces {

	var faces = make(faces, 0)

	for _, faceCoord := range faceCoords {

		//Lets find us some eyes
		leftEyes, rightEyes := detector.DetectEyes(image, &faceCoord)

		if len(leftEyes) == 0 || len(rightEyes) == 0 {

			//No eyes found, lets flop the picture and check again
			fmt.Println("Flopping Picture to look for eyes")

			floppedImage := opencv.DecodeImageMem(FlopImage(ToByteBuffer(image)))
			floppedFaceCoords := faceCoord

			floppedFaceCoords.Flop(pixelCoord{width: image.Width(), height: image.Height()})

			floppedLeftEyes, floppedRightEyes := detector.DetectEyes(floppedImage, &floppedFaceCoords)

			if len(leftEyes) == 0 {
				floppedRightEyes.FlopEmAll(pixelCoord{width: image.Width(), height: image.Height()})
				leftEyes = append(leftEyes, floppedRightEyes...)
			}

			if len(rightEyes) == 0 {
				floppedLeftEyes.FlopEmAll(pixelCoord{width: image.Width(), height: image.Height()})
				leftEyes = append(rightEyes, floppedLeftEyes...)
			}
		}

		leftEye, rightEye := FindBestEyes(leftEyes, rightEyes)
		faces = append(faces, face{
			coord:     faceCoord,
			eye_left:  leftEye,
			eye_right: rightEye,
		})
	}

	fmt.Println(faces)
	return faces
}
func ToImage(img *opencv.IplImage) image.Image {
	out := image.NewNRGBA(image.Rect(0, 0, img.Width(), img.Height()))
	if img.Depth() != opencv.IPL_DEPTH_8U {
		return nil // TODO return error
	}

	for y := 0; y < img.Height(); y++ {
		for x := 0; x < img.Width(); x++ {
			s := img.Get2D(x, y).Val()
			b, g, r, a := s[2], s[1], s[0], s[3]

			c := color.NRGBA{uint8(b), uint8(g), uint8(r), uint8(a)}
			out.Set(x, y, c)
		}
	}

	return out
}
func HoughCirclesWithParams(img *opencv.IplImage, dp float64, min_dist float64, param_1 float64, param_2 float64, min_radius int, maxradius int) []opencv.CircleStruct {
	var gray = opencv.CreateImage(img.Width(), img.Height(), opencv.IPL_DEPTH_8U, 1)
	opencv.CvtColor(img, gray, opencv.CV_BGR2GRAY)
	return opencv.HoughCircles(gray, dp, min_dist, param_1, param_2, 1, 500)
}
func HoughCircles1(img *opencv.IplImage) []opencv.CircleStruct {
	var gray = opencv.CreateImage(img.Width(), img.Height(), opencv.IPL_DEPTH_8U, 1)
	opencv.CvtColor(img, gray, opencv.CV_BGR2GRAY)
	return opencv.HoughCircles(gray, 15, 100, 75, 5, 25, 500)
}
Example #11
0
func cloneGreyscale(im *opencv.IplImage) *opencv.IplImage {
	w, h := im.Width(), im.Height()
	g := opencv.CreateImage(w, h, opencv.IPL_DEPTH_8U, 1)
	opencv.CvtColor(im, g, opencv.CV_BGR2GRAY)
	return g
}