[RSDK-9132] Add (Get)Image to the camera interface

components/camera/camera.go

@@ -119,6 +119,9 @@ type VideoSource interface {
 	// that may have a MIME type hint dictated in the context via gostream.WithMIMETypeHint.
 	Stream(ctx context.Context, errHandlers ...gostream.ErrorHandler) (gostream.VideoStream, error)
 
+	// GetImage returns a single image that may have a MIME type hint dictated in the context via gostream.WithMIMETypeHint.
+	GetImage(ctx context.Context) (image.Image, func(), error)
+
 	// NextPointCloud returns the next immediately available point cloud, not necessarily one
 	// a part of a sequence. In the future, there could be streaming of point clouds.
 	NextPointCloud(ctx context.Context) (pointcloud.PointCloud, error)

components/camera/camera_test.go

@@ -183,9 +183,7 @@ func TestCameraWithNoProjector(t *testing.T) {
 	_, got := pc.At(0, 0, 0)
 	test.That(t, got, test.ShouldBeTrue)
 
-	img, _, err := camera.ReadImage(
-		gostream.WithMIMETypeHint(context.Background(), rutils.WithLazyMIMEType(rutils.MimeTypePNG)),
-		noProj2)
+	img, _, err := noProj2.GetImage(gostream.WithMIMETypeHint(context.Background(), rutils.WithLazyMIMEType(rutils.MimeTypePNG)))
 	test.That(t, err, test.ShouldBeNil)
 
 	depthImg := img.(*rimage.DepthMap)
@@ -234,9 +232,7 @@ func TestCameraWithProjector(t *testing.T) {
 	_, got := pc.At(0, 0, 0)
 	test.That(t, got, test.ShouldBeTrue)
 
-	img, _, err := camera.ReadImage(
-		gostream.WithMIMETypeHint(context.Background(), rutils.MimeTypePNG),
-		cam2)
+	img, _, err := cam2.GetImage(gostream.WithMIMETypeHint(context.Background(), rutils.MimeTypePNG))
 	test.That(t, err, test.ShouldBeNil)
 
 	depthImg := img.(*rimage.DepthMap)

components/camera/client.go

@@ -228,6 +228,10 @@ func (c *client) Stream(
 	return stream, nil
 }
 
+func (c *client) GetImage(ctx context.Context) (image.Image, func(), error) {
+	return c.Read(ctx)
+}
+
 func (c *client) Images(ctx context.Context) ([]NamedImage, resource.ResponseMetadata, error) {
 	ctx, span := trace.StartSpan(ctx, "camera::client::Images")
 	defer span.End()

components/camera/client_test.go

@@ -99,13 +99,11 @@ func TestClient(t *testing.T) {
 		ts := time.UnixMilli(12345)
 		return images, resource.ResponseMetadata{CapturedAt: ts}, nil
 	}
-	injectCamera.StreamFunc = func(ctx context.Context, errHandlers ...gostream.ErrorHandler) (gostream.VideoStream, error) {
-		return gostream.NewEmbeddedVideoStreamFromReader(gostream.VideoReaderFunc(func(ctx context.Context) (image.Image, func(), error) {
-			imageReleasedMu.Lock()
-			imageReleased = true
-			imageReleasedMu.Unlock()
-			return imgPng, func() {}, nil
-		})), nil
+	injectCamera.GetImageFunc = func(ctx context.Context) (image.Image, func(), error) {
+		imageReleasedMu.Lock()
+		imageReleased = true
+		imageReleasedMu.Unlock()
+		return imgPng, func() {}, nil
 	}
 	// depth camera
 	injectCameraDepth := &inject.Camera{}
@@ -127,13 +125,11 @@ func TestClient(t *testing.T) {
 	injectCameraDepth.ProjectorFunc = func(ctx context.Context) (transform.Projector, error) {
 		return projA, nil
 	}
-	injectCameraDepth.StreamFunc = func(ctx context.Context, errHandlers ...gostream.ErrorHandler) (gostream.VideoStream, error) {
-		return gostream.NewEmbeddedVideoStreamFromReader(gostream.VideoReaderFunc(func(ctx context.Context) (image.Image, func(), error) {
-			imageReleasedMu.Lock()
-			imageReleased = true
-			imageReleasedMu.Unlock()
-			return depthImg, func() {}, nil
-		})), nil
+	injectCameraDepth.GetImageFunc = func(ctx context.Context) (image.Image, func(), error) {
+		imageReleasedMu.Lock()
+		imageReleased = true
+		imageReleasedMu.Unlock()
+		return depthImg, func() {}, nil
 	}
 	// bad camera
 	injectCamera2 := &inject.Camera{}
@@ -146,8 +142,8 @@ func TestClient(t *testing.T) {
 	injectCamera2.ProjectorFunc = func(ctx context.Context) (transform.Projector, error) {
 		return nil, errCameraProjectorFailed
 	}
-	injectCamera2.StreamFunc = func(ctx context.Context, errHandlers ...gostream.ErrorHandler) (gostream.VideoStream, error) {
-		return nil, errStreamFailed
+	injectCamera2.GetImageFunc = func(ctx context.Context) (image.Image, func(), error) {
+		return nil, func() {}, errGetImageFailed
 	}
 
 	resources := map[resource.Name]camera.Camera{
@@ -181,7 +177,7 @@ func TestClient(t *testing.T) {
 		camera1Client, err := camera.NewClientFromConn(context.Background(), conn, "", camera.Named(testCameraName), logger)
 		test.That(t, err, test.ShouldBeNil)
 		ctx := gostream.WithMIMETypeHint(context.Background(), rutils.MimeTypeRawRGBA)
-		frame, _, err := camera.ReadImage(ctx, camera1Client)
+		frame, _, err := camera1Client.GetImage(ctx)
 		test.That(t, err, test.ShouldBeNil)
 		compVal, _, err := rimage.CompareImages(img, frame)
 		test.That(t, err, test.ShouldBeNil)
@@ -232,7 +228,7 @@ func TestClient(t *testing.T) {
 
 		ctx := gostream.WithMIMETypeHint(
 			context.Background(), rutils.WithLazyMIMEType(rutils.MimeTypePNG))
-		frame, _, err := camera.ReadImage(ctx, client)
+		frame, _, err := client.GetImage(ctx)
 		test.That(t, err, test.ShouldBeNil)
 		dm, err := rimage.ConvertImageToDepthMap(context.Background(), frame)
 		test.That(t, err, test.ShouldBeNil)
@@ -251,9 +247,9 @@ func TestClient(t *testing.T) {
 		client2, err := resourceAPI.RPCClient(context.Background(), conn, "", camera.Named(failCameraName), logger)
 		test.That(t, err, test.ShouldBeNil)
 
-		_, _, err = camera.ReadImage(context.Background(), client2)
+		_, _, err = client2.GetImage(context.Background())
 		test.That(t, err, test.ShouldNotBeNil)
-		test.That(t, err.Error(), test.ShouldContainSubstring, errStreamFailed.Error())
+		test.That(t, err.Error(), test.ShouldContainSubstring, errGetImageFailed.Error())
 
 		_, err = client2.NextPointCloud(context.Background())
 		test.That(t, err, test.ShouldNotBeNil)
@@ -272,63 +268,63 @@ func TestClient(t *testing.T) {
 		camClient, err := camera.NewClientFromConn(context.Background(), conn, "", camera.Named(testCameraName), logger)
 		test.That(t, err, test.ShouldBeNil)
 
-		injectCamera.StreamFunc = func(ctx context.Context, errHandlers ...gostream.ErrorHandler) (gostream.VideoStream, error) {
+		injectCamera.GetImageFunc = func(ctx context.Context) (image.Image, func(), error) {
 			extra, ok := camera.FromContext(ctx)
 			test.That(t, ok, test.ShouldBeTrue)
 			test.That(t, extra, test.ShouldBeEmpty)
-			return nil, errStreamFailed
+			return nil, func() {}, errGetImageFailed
 		}
 
 		ctx := context.Background()
-		_, _, err = camera.ReadImage(ctx, camClient)
+		_, _, err = camClient.GetImage(ctx)
 		test.That(t, err, test.ShouldNotBeNil)
-		test.That(t, err.Error(), test.ShouldContainSubstring, errStreamFailed.Error())
+		test.That(t, err.Error(), test.ShouldContainSubstring, errGetImageFailed.Error())
 
-		injectCamera.StreamFunc = func(ctx context.Context, errHandlers ...gostream.ErrorHandler) (gostream.VideoStream, error) {
+		injectCamera.GetImageFunc = func(ctx context.Context) (image.Image, func(), error) {
 			extra, ok := camera.FromContext(ctx)
 			test.That(t, ok, test.ShouldBeTrue)
 			test.That(t, len(extra), test.ShouldEqual, 1)
 			test.That(t, extra["hello"], test.ShouldEqual, "world")
-			return nil, errStreamFailed
+			return nil, func() {}, errGetImageFailed
 		}
 
 		// one kvp created with camera.Extra
 		ext := camera.Extra{"hello": "world"}
 		ctx = camera.NewContext(ctx, ext)
-		_, _, err = camera.ReadImage(ctx, camClient)
+		_, _, err = camClient.GetImage(ctx)
 		test.That(t, err, test.ShouldNotBeNil)
-		test.That(t, err.Error(), test.ShouldContainSubstring, errStreamFailed.Error())
+		test.That(t, err.Error(), test.ShouldContainSubstring, errGetImageFailed.Error())
 
-		injectCamera.StreamFunc = func(ctx context.Context, errHandlers ...gostream.ErrorHandler) (gostream.VideoStream, error) {
+		injectCamera.GetImageFunc = func(ctx context.Context) (image.Image, func(), error) {
 			extra, ok := camera.FromContext(ctx)
 			test.That(t, ok, test.ShouldBeTrue)
 			test.That(t, len(extra), test.ShouldEqual, 1)
 			test.That(t, extra[data.FromDMString], test.ShouldBeTrue)
 
-			return nil, errStreamFailed
+			return nil, func() {}, errGetImageFailed
 		}
 
 		// one kvp created with data.FromDMContextKey
 		ctx = context.WithValue(context.Background(), data.FromDMContextKey{}, true)
-		_, _, err = camera.ReadImage(ctx, camClient)
+		_, _, err = camClient.GetImage(ctx)
 		test.That(t, err, test.ShouldNotBeNil)
-		test.That(t, err.Error(), test.ShouldContainSubstring, errStreamFailed.Error())
+		test.That(t, err.Error(), test.ShouldContainSubstring, errGetImageFailed.Error())
 
-		injectCamera.StreamFunc = func(ctx context.Context, errHandlers ...gostream.ErrorHandler) (gostream.VideoStream, error) {
+		injectCamera.GetImageFunc = func(ctx context.Context) (image.Image, func(), error) {
 			extra, ok := camera.FromContext(ctx)
 			test.That(t, ok, test.ShouldBeTrue)
 			test.That(t, len(extra), test.ShouldEqual, 2)
 			test.That(t, extra["hello"], test.ShouldEqual, "world")
 			test.That(t, extra[data.FromDMString], test.ShouldBeTrue)
-			return nil, errStreamFailed
+			return nil, func() {}, errGetImageFailed
 		}
 
 		// merge values from data and camera
 		ext = camera.Extra{"hello": "world"}
 		ctx = camera.NewContext(ctx, ext)
-		_, _, err = camera.ReadImage(ctx, camClient)
+		_, _, err = camClient.GetImage(ctx)
 		test.That(t, err, test.ShouldNotBeNil)
-		test.That(t, err.Error(), test.ShouldContainSubstring, errStreamFailed.Error())
+		test.That(t, err.Error(), test.ShouldContainSubstring, errGetImageFailed.Error())
 
 		test.That(t, conn.Close(), test.ShouldBeNil)
 	})
@@ -453,16 +449,14 @@ func TestClientLazyImage(t *testing.T) {
 	imgPng, err := png.Decode(bytes.NewReader(imgBuf.Bytes()))
 	test.That(t, err, test.ShouldBeNil)
 
-	injectCamera.StreamFunc = func(ctx context.Context, errHandlers ...gostream.ErrorHandler) (gostream.VideoStream, error) {
-		return gostream.NewEmbeddedVideoStreamFromReader(gostream.VideoReaderFunc(func(ctx context.Context) (image.Image, func(), error) {
-			mimeType, _ := rutils.CheckLazyMIMEType(gostream.MIMETypeHint(ctx, rutils.MimeTypeRawRGBA))
-			switch mimeType {
-			case rutils.MimeTypePNG:
-				return imgPng, func() {}, nil
-			default:
-				return nil, nil, errInvalidMimeType
-			}
-		})), nil
+	injectCamera.GetImageFunc = func(ctx context.Context) (image.Image, func(), error) {
+		mimeType, _ := rutils.CheckLazyMIMEType(gostream.MIMETypeHint(ctx, rutils.MimeTypeRawRGBA))
+		switch mimeType {
+		case rutils.MimeTypePNG:
+			return imgPng, func() {}, nil
+		default:
+			return nil, nil, errInvalidMimeType
+		}
 	}
 
 	resources := map[resource.Name]camera.Camera{
@@ -484,15 +478,15 @@ func TestClientLazyImage(t *testing.T) {
 	test.That(t, err, test.ShouldBeNil)
 
 	ctx := gostream.WithMIMETypeHint(context.Background(), rutils.MimeTypePNG)
-	frame, _, err := camera.ReadImage(ctx, camera1Client)
+	frame, _, err := camera1Client.GetImage(ctx)
 	test.That(t, err, test.ShouldBeNil)
 	// Should always lazily decode
 	test.That(t, frame, test.ShouldHaveSameTypeAs, &rimage.LazyEncodedImage{})
 	frameLazy := frame.(*rimage.LazyEncodedImage)
 	test.That(t, frameLazy.RawData(), test.ShouldResemble, imgBuf.Bytes())
 
 	ctx = gostream.WithMIMETypeHint(context.Background(), rutils.WithLazyMIMEType(rutils.MimeTypePNG))
-	frame, _, err = camera.ReadImage(ctx, camera1Client)
+	frame, _, err = camera1Client.GetImage(ctx)
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, frame, test.ShouldHaveSameTypeAs, &rimage.LazyEncodedImage{})
 	frameLazy = frame.(*rimage.LazyEncodedImage)
@@ -582,10 +576,8 @@ func TestClientStreamAfterClose(t *testing.T) {
 	injectCamera.PropertiesFunc = func(ctx context.Context) (camera.Properties, error) {
 		return camera.Properties{}, nil
 	}
-	injectCamera.StreamFunc = func(ctx context.Context, errHandlers ...gostream.ErrorHandler) (gostream.VideoStream, error) {
-		return gostream.NewEmbeddedVideoStreamFromReader(gostream.VideoReaderFunc(func(ctx context.Context) (image.Image, func(), error) {
-			return img, func() {}, nil
-		})), nil
+	injectCamera.GetImageFunc = func(ctx context.Context) (image.Image, func(), error) {
+		return img, func() {}, nil
 	}
 
 	// Register CameraService API in our gRPC server.

components/camera/collector.go

@@ -96,7 +96,7 @@ func newReadImageCollector(resource interface{}, params data.CollectorParams) (d
 
 		ctx = context.WithValue(ctx, data.FromDMContextKey{}, true)
 
-		img, release, err := ReadImage(ctx, camera)
+		img, release, err := camera.GetImage(ctx)
 		if err != nil {
 			// A modular filter component can be created to filter the readings from a component. The error ErrNoCaptureToStore
 			// is used in the datamanager to exclude readings from being captured and stored.

components/camera/fake/camera_test.go

@@ -93,9 +93,7 @@ func TestRTPPassthrough(t *testing.T) {
 		camera, err := NewCamera(context.Background(), nil, cfg, logger)
 		test.That(t, err, test.ShouldBeNil)
 
-		stream, err := camera.Stream(context.Background())
-		test.That(t, err, test.ShouldBeNil)
-		img, _, err := stream.Next(context.Background())
+		img, _, err := camera.GetImage(context.Background())
 		test.That(t, err, test.ShouldBeNil)
 		// GetImage returns the world jpeg
 		test.That(t, img.Bounds(), test.ShouldResemble, image.Rectangle{Max: image.Point{X: 480, Y: 270}})

components/camera/fake/image_file_test.go

@@ -26,9 +26,6 @@ func TestPCD(t *testing.T) {
 	cam, err := newCamera(ctx, resource.Name{API: camera.API}, cfg, logger)
 	test.That(t, err, test.ShouldBeNil)
 
-	_, err = cam.Stream(ctx)
-	test.That(t, err, test.ShouldBeNil)
-
 	pc, err := cam.NextPointCloud(ctx)
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, pc.Size(), test.ShouldEqual, 628)
@@ -45,13 +42,10 @@ func TestPCD(t *testing.T) {
 	cam, err = newCamera(ctx, resource.Name{API: camera.API}, cfg, logger)
 	test.That(t, err, test.ShouldBeNil)
 
-	stream, err := cam.Stream(ctx)
-	test.That(t, err, test.ShouldBeNil)
-
 	readInImage, err := rimage.NewImageFromFile(artifact.MustPath("vision/objectdetection/detection_test.jpg"))
 	test.That(t, err, test.ShouldBeNil)
 
-	strmImg, _, err := stream.Next(ctx)
+	strmImg, _, err := cam.GetImage(ctx)
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, strmImg, test.ShouldResemble, readInImage)
 	test.That(t, strmImg.Bounds(), test.ShouldResemble, readInImage.Bounds())
@@ -68,16 +62,13 @@ func TestColor(t *testing.T) {
 	cam, err := newCamera(ctx, resource.Name{API: camera.API}, cfg, logger)
 	test.That(t, err, test.ShouldBeNil)
 
-	stream, err := cam.Stream(ctx)
-	test.That(t, err, test.ShouldBeNil)
-
 	_, err = cam.NextPointCloud(ctx)
 	test.That(t, err, test.ShouldNotBeNil)
 
 	readInImage, err := rimage.NewImageFromFile(artifact.MustPath("vision/objectdetection/detection_test.jpg"))
 	test.That(t, err, test.ShouldBeNil)
 
-	strmImg, _, err := stream.Next(ctx)
+	strmImg, _, err := cam.GetImage(ctx)
 	test.That(t, err, test.ShouldBeNil)
 	test.That(t, strmImg, test.ShouldResemble, readInImage)
 	test.That(t, strmImg.Bounds(), test.ShouldResemble, readInImage.Bounds())
@@ -108,13 +99,10 @@ func TestColorOddResolution(t *testing.T) {
 	cam, err := newCamera(ctx, resource.Name{API: camera.API}, cfg, logger)
 	test.That(t, err, test.ShouldBeNil)
 
-	stream, err := cam.Stream(ctx)
-	test.That(t, err, test.ShouldBeNil)
-
 	readInImage, err := rimage.NewImageFromFile(imgFilePath)
 	test.That(t, err, test.ShouldBeNil)
 
-	strmImg, _, err := stream.Next(ctx)
+	strmImg, _, err := cam.GetImage(ctx)
 	test.That(t, err, test.ShouldBeNil)
 
 	expectedBounds := image.Rect(0, 0, readInImage.Bounds().Dx()-1, readInImage.Bounds().Dy()-1)

components/camera/ffmpeg/ffmpeg_test.go

@@ -17,13 +17,10 @@ func TestFFMPEGCamera(t *testing.T) {
 	path := artifact.MustPath("components/camera/ffmpeg/testsrc.mpg")
 	cam, err := NewFFMPEGCamera(ctx, &Config{VideoPath: path}, logger)
 	test.That(t, err, test.ShouldBeNil)
-	stream, err := cam.Stream(ctx)
-	test.That(t, err, test.ShouldBeNil)
 	for i := 0; i < 5; i++ {
-		_, _, err := stream.Next(ctx)
+		_, _, err := cam.GetImage(ctx)
 		test.That(t, err, test.ShouldBeNil)
 	}
-	test.That(t, stream.Close(context.Background()), test.ShouldBeNil)
 	test.That(t, cam.Close(context.Background()), test.ShouldBeNil)
 }
 

components/camera/replaypcd/replaypcd.go

@@ -4,6 +4,7 @@ package replaypcd
 import (
 	"bytes"
 	"context"
+	"image"
 	"net/http"
 	"sync"
 	"time"
@@ -346,6 +347,19 @@ func (replay *pcdCamera) Stream(ctx context.Context, errHandlers ...gostream.Err
 	return stream, errors.New("Stream is unimplemented")
 }
 
+func (replay *pcdCamera) GetImage(ctx context.Context) (image.Image, func(), error) {
+	stream, err := replay.Stream(ctx)
+	if err != nil {
+		return nil, func() {}, err
+	}
+	defer func() {
+		if err := stream.Close(ctx); err != nil {
+			replay.logger.Errorf("stream failed to close: %w", err)
+		}
+	}()
+	return stream.Next(ctx)
+}
+
 // Close stops replay camera, closes the channels and its connections to the cloud.
 func (replay *pcdCamera) Close(ctx context.Context) error {
 	replay.mu.Lock()

components/camera/replaypcd/replaypcd_test.go

@@ -660,11 +660,6 @@ func TestReplayPCDUnimplementedFunctions(t *testing.T) {
 	replayCamera, _, serverClose, err := createNewReplayPCDCamera(ctx, t, replayCamCfg, true)
 	test.That(t, err, test.ShouldBeNil)
 
-	t.Run("Stream", func(t *testing.T) {
-		_, err := replayCamera.Stream(ctx, nil)
-		test.That(t, err.Error(), test.ShouldEqual, "Stream is unimplemented")
-	})
-
 	err = replayCamera.Close(ctx)
 	test.That(t, err, test.ShouldBeNil)
 

components/camera/server.go

@@ -93,7 +93,7 @@ func (s *serviceServer) GetImage(
 		// network. Just to be discarded.
 		img, release, err = castedCam.Read(ctx)
 	default:
-		img, release, err = ReadImage(gostream.WithMIMETypeHint(ctx, req.MimeType), cam)
+		img, release, err = cam.GetImage(gostream.WithMIMETypeHint(ctx, req.MimeType))
 	}
 	if err != nil {
 		return nil, err