label-3d-points/public/js/calib.js

import {
  rotation_matrix_to_euler_angle,
  euler_angle_to_rotate_matrix,
  matmul,
  transpose,
} from "./util.js";
//import {render_2d_image, update_image_box_projection} from "./image.js"

function Calib(data, editor) {
  this.data = data;
  this.editor = editor;

  var euler_angle = { x: 0, y: 0, y: 0 };
  var translate = { x: 0, y: 0, z: 0 };

  this.save_calibration = function () {
    var scene_meta = data.meta[data.world.frameInfo.scene];

    var active_camera_name = data.world.cameras.active_name;
    var calib = scene_meta.calib.camera[active_camera_name];

    var extrinsic = calib.extrinsic.map(function (x) {
      return x * 1.0;
    });

    euler_angle = rotation_matrix_to_euler_angle(extrinsic);
    translate = {
      x: extrinsic[3] * 1.0,
      y: extrinsic[7] * 1.0,
      z: extrinsic[11] * 1.0,
    };

    console.log(extrinsic, euler_angle, translate);

    let matrix = euler_angle_to_rotate_matrix(euler_angle, translate);
    console.log("restoreed matrix", matrix);

    this.editor.infoBox.show("calib", JSON.stringify(matrix));
  };

  this.reset_calibration = function () {
    // to be done
    this.editor.imageContextManager.render_2d_image();
  };

  this.calib_box = null;

  this.show_camera_pos = function () {
    this.editor.viewManager.mainView.dumpPose();
  };

  // show a manipulating box
  this.start_calibration = function () {
    var scene_meta = this.data.meta[data.world.frameInfo.scene];

    var active_camera_name = this.data.world.cameras.active_name;
    var calib = scene_meta.calib.camera[active_camera_name];
    var extrinsic = calib.extrinsic.map(function (x) {
      return x * 1.0;
    });
    let viewMatrix = [
      0,
      -1,
      0,
      0, //row vector
      0,
      0,
      -1,
      0,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
    ];
    function transpose_transmatrix(m) {
      //m=4*4
      return [
        m[0],
        m[4],
        m[8],
        m[3],
        m[1],
        m[5],
        m[9],
        m[7],
        m[2],
        m[6],
        m[10],
        m[11],
        m[12],
        m[13],
        m[14],
        m[15],
      ];
    }

    var op_matrix = matmul(
      transpose_transmatrix(viewMatrix),
      transpose_transmatrix(extrinsic),
      4
    );

    var euler_angle = rotation_matrix_to_euler_angle(op_matrix);
    var translate = {
      x: extrinsic[3] * 1.0,
      y: extrinsic[7] * 1.0,
      z: extrinsic[11] * 1.0,
    };

    console.log(euler_angle, translate);
    this.show_camera_pos();

    if (!this.calib_box) {
      this.calib_box = this.data.world.annotation.createCuboid(
        {
          x: translate.x, // + this.data.world.coordinatesOffset[0],
          y: translate.y, // + this.data.world.coordinatesOffset[1],
          z: translate.z, // + this.data.world.coordinatesOffset[2]
        },
        { x: 1, y: 1, z: 1 },
        {
          x: euler_angle.x,
          y: euler_angle.y,
          z: euler_angle.z,
        },
        "camera",
        "camera"
      );

      this.data.world.scene.add(this.calib_box);
    } else {
      console.log("calib box exists.");
      this.calib_box.position.x = translate.x; // + this.data.world.coordinatesOffset[0];
      this.calib_box.position.y = translate.y; // + this.data.world.coordinatesOffset[1];
      this.calib_box.position.z = translate.z; // + this.data.world.coordinatesOffset[2];

      this.calib_box.rotation.x = euler_angle.x;
      this.calib_box.rotation.y = euler_angle.y;
      this.calib_box.rotation.z = euler_angle.z;
    }

    console.log(this.calib_box);
    this.editor.render();

    this.calib_box.on_box_changed = () => {
      console.log("calib box changed.");

      let real_pos = {
        x: this.calib_box.position.x, // - this.data.world.coordinatesOffset[0],
        y: this.calib_box.position.y, // - this.data.world.coordinatesOffset[1],
        z: this.calib_box.position.z, // - this.data.world.coordinatesOffset[2],
      };

      let extrinsic = euler_angle_to_rotate_matrix(
        this.calib_box.rotation,
        real_pos
      );
      calib.extrinsic = transpose_transmatrix(matmul(viewMatrix, extrinsic, 4));
      console.log("extrinsic", calib.extrinsic);
      console.log("euler", euler_angle, "translate", translate);

      this.editor.imageContextManager.render_2d_image();
    };
  };

  function stop_calibration() {
    //tbd
  }

  /*
    function calibrate(ax, value){
        var scene_meta = data.meta[data.world.frameInfo.scene];
    
        var active_camera_name = data.world.cameras.active_name;
        var calib = scene_meta.calib.camera[active_camera_name]
        var extrinsic = calib.extrinsic.map(function(x){return x*1.0;});
    
        var euler_angle = rotation_matrix_to_euler_angle(extrinsic);
        var translate = {
            x: extrinsic[3]*1.0,
            y: extrinsic[7]*1.0,
            z: extrinsic[11]*1.0,
        };
    
        if (ax == 'z'){
            euler_angle.z += value;
        }else if (ax == 'x'){
            euler_angle.x += value;
        }
        else if (ax == 'y'){
            euler_angle.y += value;
        }else if (ax == 'tz'){
            translate.z += value;
        }else if (ax == 'tx'){
            translate.x += value;
        }
        else if (ax == 'ty'){
            translate.y += value;
        }
    
        calib.extrinsic = euler_angle_to_rotate_matrix(euler_angle, translate);
    
        console.log("extrinsic", calib.extrinsic)
        console.log("euler", euler_angle, "translate", translate);    
    
        render_2d_image();
    
        if (selected_box)
            update_image_box_projection(selected_box);
    }
    */
}

export { Calib };