Renaming visible pixels metric to rendered object info.

com.unity.perception/Runtime/GroundTruth/PerceptionCamera.cs

         [FormerlySerializedAs("m_BoundingBoxID")]
         public string boundingBoxId = "F9F22E05-443F-4602-A422-EBE4EA9B55CB";
         /// <summary>
-        /// Whether visible pixels should be computed for each labeled object
+        /// Whether rendered object info metrics should be generated. This metric currently contains label id, instance id, and visible pixels.
-        public bool produceVisiblePixelsMetric = true;
+        [FormerlySerializedAs("produceVisiblePixelsMetric")]
+        public bool produceRenderedObjectInfoMetric = true;
+        [FormerlySerializedAs("visiblePixelsId")]
-        public string visiblePixelsId = "5BA92024-B3B7-41A7-9D3F-C03A6A8DDD01";
+        public string renderedObjectInfoId = "5BA92024-B3B7-41A7-9D3F-C03A6A8DDD01";
         /// <summary>
         /// The corner of the image to use as the origin for bounding boxs.
         /// </summary>
         public LabelingConfiguration LabelingConfiguration;
 
         /// <summary>
-        /// Invoked when RenderedObjectInfos (bounding boxes) are calculated. The first parameter is the Time.frameCount at which the objects were rendered. This may be called many frames after the frame in which the objects were rendered.
+        /// Invoked when RenderedObjectInfos are calculated. The first parameter is the Time.frameCount at which the objects were rendered. This may be called many frames after the frame in which the objects were rendered.
         /// </summary>
         public event Action<int, NativeArray<RenderedObjectInfo>> renderedObjectInfosCalculated;
 
             public int FrameCount;
             public AsyncAnnotation SegmentationAsyncAnnotation;
             public AsyncMetric ClassCountAsyncMetric;
-            public AsyncMetric VisiblePixelsAsyncMetric;
+            public AsyncMetric RenderedObjectInfoAsyncMetric;
             public AsyncAnnotation BoundingBoxAsyncMetric;
         }
 
 
         ClassCountValue[] m_ClassCountValues;
         BoundingBoxValue[] m_BoundingBoxValues;
-        VisiblePixelsValue[] m_VisiblePixelsValues;
+        RenderedObjectInfoValue[] m_VisiblePixelsValues;
 
 #if HDRP_PRESENT
         InstanceSegmentationPass m_SegmentationPass;
         AnnotationDefinition m_BoundingBoxAnnotationDefinition;
         AnnotationDefinition m_SegmentationAnnotationDefinition;
-        MetricDefinition m_VisiblePixelsMetricDefinition;
+        MetricDefinition m_RenderedObjectInfoMetricDefinition;
 
         static ProfilerMarker s_WriteFrame = new ProfilerMarker("Write Frame (PerceptionCamera)");
         static ProfilerMarker s_FlipY = new ProfilerMarker("Flip Y (PerceptionCamera)");
         static ProfilerMarker s_BoundingBoxCallback = new ProfilerMarker("OnBoundingBoxesReceived");
-        static ProfilerMarker s_ProduceVisiblePixelsMetric = new ProfilerMarker("ProduceVisiblePixelsMetric");
+        static ProfilerMarker s_ProduceRenderedObjectInfoMetric = new ProfilerMarker("ProduceRenderedObjectInfoMetric");
 
         [SuppressMessage("ReSharper", "InconsistentNaming")]
         struct SemanticSegmentationSpec
                     (frameCount, data, tex) => OnSemanticSegmentationImageRead(frameCount, data));
             }
 
-            if (produceObjectCountAnnotations || produceBoundingBoxAnnotations)
+            if (produceObjectCountAnnotations || produceBoundingBoxAnnotations || produceRenderedObjectInfoMetric)
             {
                 var labelingMetricSpec = LabelingConfiguration.LabelingConfigurations.Select((l, index) => new ObjectCountSpec()
                 {
 
                 if (produceBoundingBoxAnnotations)
                 {
-                    m_BoundingBoxAnnotationDefinition = SimulationManager.RegisterAnnotationDefinition("bounding box", labelingMetricSpec, "Bounding boxe for each labeled object visible to the sensor", id: new Guid(boundingBoxId));
+                    m_BoundingBoxAnnotationDefinition = SimulationManager.RegisterAnnotationDefinition("bounding box", labelingMetricSpec, "Bounding box for each labeled object visible to the sensor", id: new Guid(boundingBoxId));
-                if (produceVisiblePixelsMetric)
-                    m_VisiblePixelsMetricDefinition = SimulationManager.RegisterMetricDefinition("visible pixels", labelingMetricSpec, "Visible pixels for each visible object", id: new Guid(visiblePixelsId));
+                if (produceRenderedObjectInfoMetric)
+                    m_RenderedObjectInfoMetricDefinition = SimulationManager.RegisterMetricDefinition("rendered object info", labelingMetricSpec, "Information about each labeled object visible to the sensor", id: new Guid(renderedObjectInfoId));
 
                 m_RenderedObjectInfoGenerator = new RenderedObjectInfoGenerator(LabelingConfiguration);
                 World.DefaultGameObjectInjectionWorld.GetExistingSystem<GroundTruthLabelSetupSystem>().Activate(m_RenderedObjectInfoGenerator);
                     if (produceBoundingBoxAnnotations)
                         ProduceBoundingBoxesAnnotation(renderedObjectInfos, LabelingConfiguration.LabelingConfigurations, frameCount);
 
-                    if (produceVisiblePixelsMetric)
-                        ProduceVisiblePixelsMetric(renderedObjectInfos, frameCount);
+                    if (produceRenderedObjectInfoMetric)
+                        ProduceRenderedObjectInfoMetric(renderedObjectInfos, frameCount);
                 });
             }
 
 
         // ReSharper disable InconsistentNaming
-        struct VisiblePixelsValue
+        struct RenderedObjectInfoValue
         {
             [UsedImplicitly]
             public int label_id;
         }
         // ReSharper restore InconsistentNaming
 
-        void ProduceVisiblePixelsMetric(NativeArray<RenderedObjectInfo> renderedObjectInfos, int frameCount)
+        void ProduceRenderedObjectInfoMetric(NativeArray<RenderedObjectInfo> renderedObjectInfos, int frameCount)
-            using (s_ProduceVisiblePixelsMetric.Auto())
+            using (s_ProduceRenderedObjectInfoMetric.Auto())
-                var visiblePixelsAsyncMetric = asyncCaptureInfo.VisiblePixelsAsyncMetric;
-                if (!visiblePixelsAsyncMetric.IsValid)
+                var metric = asyncCaptureInfo.RenderedObjectInfoAsyncMetric;
+                if (!metric.IsValid)
-                    m_VisiblePixelsValues = new VisiblePixelsValue[renderedObjectInfos.Length];
+                    m_VisiblePixelsValues = new RenderedObjectInfoValue[renderedObjectInfos.Length];
 
                 for (var i = 0; i < renderedObjectInfos.Length; i++)
                 {
 
-                    m_VisiblePixelsValues[i] = new VisiblePixelsValue
+                    m_VisiblePixelsValues[i] = new RenderedObjectInfoValue
                     {
                         label_id = labelId,
                         instance_id = objectInfo.instanceId,
 
-                visiblePixelsAsyncMetric.ReportValues(m_VisiblePixelsValues);
+                metric.ReportValues(m_VisiblePixelsValues);
             }
         }
 
             m_AsyncCaptureInfos.RemoveSwapBack(i =>
                 !i.SegmentationAsyncAnnotation.IsPending &&
                 !i.BoundingBoxAsyncMetric.IsPending &&
-                !i.VisiblePixelsAsyncMetric.IsPending &&
+                !i.RenderedObjectInfoAsyncMetric.IsPending &&
-            if (produceSegmentationImages || produceObjectCountAnnotations || produceBoundingBoxAnnotations || produceVisiblePixelsMetric)
+            if (produceSegmentationImages || produceObjectCountAnnotations || produceBoundingBoxAnnotations || produceRenderedObjectInfoMetric)
             {
                 var captureInfo = new AsyncCaptureInfo()
                 {
                 if (produceBoundingBoxAnnotations)
                     captureInfo.BoundingBoxAsyncMetric = SensorHandle.ReportAnnotationAsync(m_BoundingBoxAnnotationDefinition);
 
-                if (produceVisiblePixelsMetric)
-                    captureInfo.VisiblePixelsAsyncMetric = SensorHandle.ReportMetricAsync(m_VisiblePixelsMetricDefinition);
+                if (produceRenderedObjectInfoMetric)
+                    captureInfo.RenderedObjectInfoAsyncMetric = SensorHandle.ReportMetricAsync(m_RenderedObjectInfoMetricDefinition);
 
                 m_AsyncCaptureInfos.Add(captureInfo);
             }