Bugfixes and fully working automatic data gathering.

managed/GTAVision.ini

@@ -1,5 +1,7 @@
 [Database]
-ConnectionString=Server=127.0.0.1;Port=5432;Database=postgres;User Id=postgres;Password=postgres;
+ConnectionString=Server=127.0.0.1;Port=5432;Database=gta_v;User Id=postgres;Password=postgres;
 [Snapshots]
 OutputDir=D:\GTAV_extraction_output\
-LogFile=D:\GTAV_extraction_output\log.txt
+LogFile=D:\Program Files\Rockstar Games\Grand Theft Auto V\my_log.txt
+[MultiCamera]
+GameplayTimeAfterSwitch=2000

managed/GTAVisionExport.sln

@@ -9,6 +9,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GTAVisionUtils", "GTAVision
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ImageViewer", "ImageViewer\ImageViewer.csproj", "{30284E7F-F081-42AA-AC6A-6D4267E87024}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Sandbox", "Sandbox\Sandbox.csproj", "{35EC1C44-BEB8-4CF7-A5D8-AD3A2A029A5C}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -41,6 +43,14 @@ Global
 		{30284E7F-F081-42AA-AC6A-6D4267E87024}.Release|Any CPU.Build.0 = Release|Any CPU
 		{30284E7F-F081-42AA-AC6A-6D4267E87024}.Release|x64.ActiveCfg = Release|Any CPU
 		{30284E7F-F081-42AA-AC6A-6D4267E87024}.Release|x64.Build.0 = Release|Any CPU
+		{35EC1C44-BEB8-4CF7-A5D8-AD3A2A029A5C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{35EC1C44-BEB8-4CF7-A5D8-AD3A2A029A5C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{35EC1C44-BEB8-4CF7-A5D8-AD3A2A029A5C}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{35EC1C44-BEB8-4CF7-A5D8-AD3A2A029A5C}.Debug|x64.Build.0 = Debug|Any CPU
+		{35EC1C44-BEB8-4CF7-A5D8-AD3A2A029A5C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{35EC1C44-BEB8-4CF7-A5D8-AD3A2A029A5C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{35EC1C44-BEB8-4CF7-A5D8-AD3A2A029A5C}.Release|x64.ActiveCfg = Release|Any CPU
+		{35EC1C44-BEB8-4CF7-A5D8-AD3A2A029A5C}.Release|x64.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

managed/GTAVisionExport/CameraHandling.cs

@@ -0,0 +1,188 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+using System.Collections.Generic;
+using System.Linq;
+using GTA;
+using GTA.Native;
+using GTA.Math;
+using GTA.NaturalMotion;
+using GTAVisionUtils;
+using MathNet.Spatial.Euclidean;
+using MathNet.Spatial.Units;
+
+namespace GTAVisionExport {
+// Controls: 
+// P - mounts rendering camera on vehicle 
+// O - restores the rendering camera to original control
+
+    public class CameraHandling : Script {
+        // camera used on the vehicle
+        private Camera activeCamera;
+        private bool enabled = false;
+        private int activeCameraIndex = -1;
+        private bool showCameras = false;
+
+        public CameraHandling() {
+            UI.Notify("Loaded CameraHandling.cs");
+
+            // create a new camera 
+//            World.DestroyAllCameras();
+
+            // attach time methods 
+            Tick += OnTick;
+            KeyUp += onKeyUp;
+        }
+
+        // Function used to take control of the world rendering camera.
+        public void mountCameraOnVehicle() {
+            UI.Notify("Mounting camera to the vehicle.");
+            if (Game.Player.Character.IsInVehicle()) {
+                if (activeCameraIndex == -1) {
+                    UI.Notify("Mounting main camera");
+                    CamerasList.ActivateMainCamera();
+                }
+                else {
+                    UI.Notify("Mounting camera from list");
+                    UI.Notify("My current rotation: " + Game.Player.Character.CurrentVehicle.Rotation);
+                    Logger.writeLine("My current rotation: " + Game.Player.Character.CurrentVehicle.Rotation);
+                    activeCamera = CamerasList.ActivateCamera(activeCameraIndex);
+                }
+            }
+            else {
+                UI.Notify("Please enter a vehicle.");
+            }
+        }
+
+        // Function used to allows the user original control of the camera.
+        public void restoreCamera() {
+            UI.Notify("Relinquishing control");
+            CamerasList.Deactivate();
+        }
+
+        // Function used to keep camera on vehicle and facing forward on each tick step.
+        public void keepCameraOnVehicle() {
+            if (Game.Player.Character.IsInVehicle() && enabled) {
+                // keep the camera in the same position relative to the car
+                CamerasList.mainCamera.AttachTo(Game.Player.Character.CurrentVehicle, CamerasList.mainCameraPosition);
+
+                // rotate the camera to face the same direction as the car 
+                CamerasList.mainCamera.Rotation = Game.Player.Character.CurrentVehicle.Rotation;
+            }
+        }
+
+        // Test vehicle controls 
+        private void onKeyUp(object sender, KeyEventArgs e) {
+            if (e.KeyCode == Keys.P) {
+                activeCameraIndex = -1;
+                mountCameraOnVehicle();
+                enabled = true;
+            }
+
+            if (e.KeyCode == Keys.O) {
+                restoreCamera();
+                enabled = false;
+            }
+
+//            UI.Notify("keycode is:" + e.KeyCode);
+
+            if (e.KeyCode == Keys.Add) {
+                UI.Notify("Pressed numpad +");
+                showCameras = !showCameras;
+                UI.Notify("there are " + CamerasList.camerasPositions.Count + " cameras");
+                if (showCameras) {
+                    UI.Notify("enabled cameras showing");
+                }
+                else {
+                    UI.Notify("disabled cameras showing");
+                }
+
+            }
+
+            if (e.KeyCode == Keys.NumPad0) {
+                UI.Notify("Pressed numpad 0");
+                activeCameraIndex = 0;
+                mountCameraOnVehicle();
+            }
+
+            if (e.KeyCode == Keys.NumPad1) {
+                UI.Notify("Pressed numpad 1");
+                activeCameraIndex = 1;
+                mountCameraOnVehicle();
+            }
+
+            if (e.KeyCode == Keys.NumPad2) {
+                UI.Notify("Pressed numpad 2");
+                activeCameraIndex = 2;
+                mountCameraOnVehicle();
+            }
+
+            if (e.KeyCode == Keys.NumPad3) {
+                UI.Notify("Pressed numpad 3");
+                activeCameraIndex = 3;
+                mountCameraOnVehicle();
+            }
+
+            if (e.KeyCode == Keys.Decimal) {
+                UI.Notify("Pressed numpad ,");
+                activeCameraIndex = -1;
+                mountCameraOnVehicle();
+            }
+        }
+
+        void OnTick(object sender, EventArgs e) {
+            keepCameraOnVehicle();
+            if (showCameras) {
+                drawCamerasBoxes();
+            }
+//            drawAxesBoxesAround(new Vector3(-1078f, -216f, 200f));
+        }
+
+        void drawCamerasBoxes() {
+//            this shows white boxes where cameras are
+            foreach (var camPos in CamerasList.camerasPositions) {
+                var curVehicle = Game.Player.Character.CurrentVehicle;
+//                Logger.writeLine("rotation");
+//                Logger.writeLine(curVehicle.Rotation);
+//                Logger.writeLine("forward vector");
+//                Logger.writeLine(curVehicle.ForwardVector);
+//                Logger.writeLine("right vector");
+//                Logger.writeLine(curVehicle.RightVector);
+//                Logger.writeLine("up vector");
+//                Logger.writeLine(curVehicle.UpVector);
+//                var camPosToCar = Vector3.Modulate(curVehicle.ForwardVector, cameraPosition);
+//                camPosToCar += Vector3.Modulate(curVehicle.RightVector, cameraPosition);
+//                camPosToCar += Vector3.Modulate(curVehicle.UpVector, cameraPosition);
+                var rot = curVehicle.Rotation;
+                var rotX = Matrix3D.RotationAroundXAxis(Angle.FromDegrees(rot.X));
+                var rotY = Matrix3D.RotationAroundYAxis(Angle.FromDegrees(rot.Y));
+                var rotZ = Matrix3D.RotationAroundZAxis(Angle.FromDegrees(rot.Z));
+                var rotMat = rotX * rotY * rotZ;
+                var camPosToCar = rotMat * new Vector3D(camPos.X, camPos.Y, camPos.Z);
+                var absolutePosition = curVehicle.Position + new Vector3((float) camPosToCar[0], (float) camPosToCar[1], (float) camPosToCar[2]);
+                HashFunctions.Draw3DBox(absolutePosition, new Vector3(0.3f, 0.3f, 0.3f));
+            }
+        }
+
+        void drawAxesBoxesAround(Vector3 position) {
+            var dist = 10;
+            var vectors = new[] {
+                new Vector3(dist, 0, 0), new Vector3(-dist, 0, 0), // x, pos and neg
+                new Vector3(0, dist, 0), new Vector3(0, -dist, 0), // y, pos and neg 
+                new Vector3(0, 0, dist), new Vector3(0, 0, -dist), // z, pos and neg
+            };
+            var colors = new[] {
+                new Vector3(255, 0, 0), new Vector3(255, 180, 180), // x, pos and neg
+                new Vector3(0, 255, 0), new Vector3(180, 255, 180), // y, pos and neg 
+                new Vector3(0, 0, 255), new Vector3(180, 180, 255), // z, pos and neg
+            };
+            for (int i = 0; i < vectors.Length; i++) {
+                var relativePos = vectors[i];
+                var color = colors[i];
+                var absolutePosition = position + new Vector3((float) relativePos[0], (float) relativePos[1], (float) relativePos[2]);
+                HashFunctions.Draw3DBox(absolutePosition, new Vector3(0.3f, 0.3f, 0.3f), 
+                    (byte) colors[i][0], (byte) colors[i][1], (byte) colors[i][2]);
+            }
+        }
+    }
+}

managed/GTAVisionExport/CamerasList.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using GTA;
+using GTA.Math;
+using GTA.Native;
+using GTAVisionUtils;
+using IniParser;
+
+namespace GTAVisionExport {
+    public static class CamerasList {
+        public static Camera mainCamera { get; private set; }
+        public static Vector3 mainCameraPosition { get; private set; }
+        public static Vector3 mainCameraRotation { get; private set; }
+
+        public static List<Camera> cameras { get; } = new List<Camera>();
+        public static List<Vector3> camerasPositions { get; } = new List<Vector3>();
+        public static List<Vector3> camerasRotations { get; } = new List<Vector3>();
+
+        public static Vector3? activeCameraRotation { get; private set; } = null;
+        public static Vector3? activeCameraPosition { get; private set; } = null;
+
+        private static int? gameplayInterval = null;
+
+//        public static Camera gameCam;
+        private static bool initialized = false;
+
+        public static void initialize() {
+            if (initialized) {
+                return;
+            }
+
+            World.DestroyAllCameras();
+            Logger.writeLine("destroying all cameras at the beginning, to be clear");
+            var parser = new FileIniDataParser();
+            var data = parser.ReadFile(Path.Combine(VisionExport.location, "GTAVision.ini"));
+            gameplayInterval = Convert.ToInt32(data["MultiCamera"]["GameplayTimeAfterSwitch"]);
+//            gameCam = World.RenderingCamera;
+
+//            mainCamera.IsActive = false;
+
+            initialized = true;
+        }
+
+        public static void setMainCamera(Vector3 position = new Vector3(), Vector3 rotation = new Vector3(), float? fov = null, float? nearClip = null) {
+            if (!initialized) {
+                throw new Exception("not initialized, please, call CamerasList.initialize() method before this one");
+            }
+
+            Logger.writeLine("setting main camera");
+            if (!fov.HasValue) {
+                fov = GameplayCamera.FieldOfView;
+            }
+            if (!nearClip.HasValue) {
+                nearClip = World.RenderingCamera.NearClip;
+            }
+
+            mainCamera = World.CreateCamera(position, rotation, fov.Value);
+//            mainCamera = World.CreateCamera(new Vector3(), new Vector3(), fov.Value);
+            mainCamera.NearClip = nearClip.Value;
+//            mainCamera.IsActive = true;
+            mainCameraPosition = position;
+            mainCameraRotation = rotation;
+
+            mainCamera.IsActive = false;
+            World.RenderingCamera = null;
+        }
+
+        public static void addCamera(Vector3 position, Vector3 rotation, float? fov = null, float? nearClip = null) {
+            if (!initialized) {
+                throw new Exception("not initialized, please, call CamerasList.initialize() method before this one");
+            }
+
+            Logger.writeLine("adding new camera");
+            if (!fov.HasValue) {
+                fov = GameplayCamera.FieldOfView;
+            }
+            if (!nearClip.HasValue) {
+                nearClip = World.RenderingCamera.NearClip;
+            }
+
+            var newCamera = World.CreateCamera(new Vector3(), new Vector3(), fov.Value);
+            newCamera.NearClip = nearClip.Value;
+            cameras.Add(newCamera);
+            camerasPositions.Add(position);
+            camerasRotations.Add(rotation);
+        }
+
+        public static void ActivateMainCamera() {
+            if (!initialized) {
+                throw new Exception("not initialized, please, call CamerasList.initialize() method before this one");
+            }
+
+            if (mainCamera == null) {
+                throw new Exception("please, set main camera");
+            }
+
+            mainCamera.IsActive = true;
+            World.RenderingCamera = mainCamera;
+            activeCameraRotation = mainCameraRotation;
+            activeCameraPosition = mainCameraPosition;
+        }
+
+        public static Camera ActivateCamera(int i) {
+            if (!initialized) {
+                throw new Exception("not initialized, please, call CamerasList.initialize() method before this one");
+            }
+
+            if (i >= cameras.Count) {
+                throw new Exception("there is no camera with index " + i);
+            }
+
+            Game.Pause(false);
+            cameras[i].IsActive = true;
+            World.RenderingCamera = cameras[i];
+            cameras[i].AttachTo(Game.Player.Character.CurrentVehicle, camerasPositions[i]);
+            cameras[i].Rotation = Game.Player.Character.CurrentVehicle.Rotation + camerasRotations[i];
+//            WARNING: CAMERAS SETTING DO NOT WORK WHEN GAME IS PAUSED, SO WE NEED TO UNPAUSE THE GAME, SET THINGS UP, AND THEN PAUSE GAME AGAIN
+//            Script.Wait(1);
+// //with time 1, sometimes depth does not correspond, and bounding boxes dont correspond by 3 frames
+// //with time 2, depth does correspond, but bounding boxes dont correspond by 2 frames
+// //with time 3, sometimes depth does not correspond, but bounding boxes dont correspond by 1 frames
+//            Script.Wait(4);//tried 4 milliseconds instead of one, so screenshots correspond to their data
+            Script.Wait(gameplayInterval.Value);
+            Game.Pause(true);
+//            UI.Notify("new camera rotation is: " + rotation.ToString());
+            Script.Wait(20);
+            Logger.writeLine("new camera position is: " + World.RenderingCamera.Position.ToString());
+            Logger.writeLine("new camera rotation is: " + World.RenderingCamera.Rotation.ToString());
+            Logger.writeLine("new camera position offset is: " + camerasPositions[i].ToString());
+            Logger.writeLine("new camera rotation offset is: " + camerasRotations[i].ToString());
+            activeCameraRotation = camerasRotations[i];
+            activeCameraPosition = camerasPositions[i];
+            return cameras[i];
+        }
+
+        public static void Deactivate() {
+            if (!initialized) {
+                throw new Exception("not initialized, please, call CamerasList.initialize() method before this one");
+            }
+
+            mainCamera.IsActive = false;
+            foreach (var camera in cameras) {
+                camera.IsActive = false;
+            }
+
+            World.RenderingCamera = null;
+        }
+    }
+}