ohzi-core 5.13.2 → 5.14.2

package/src/utilities/FrustumPointFitter.js

@@ -0,0 +1,255 @@
+import { Line3, Plane, Quaternion, Sphere, Vector3 } from 'three';
+
+export default class FrustumPointFitter
+{
+  constructor()
+  {
+    this.sphere = new Sphere();
+  }
+
+  fit_points(points, camera_quaternion, vertical_fov, aspect)
+  {
+    this.sphere.setFromPoints(points);
+
+    let v_fov = Math.degToRad(vertical_fov / 2);
+    let h_fov = (2 * Math.atan(Math.tan(v_fov) * aspect)) / 2;
+
+    let up_plane_normal = this.get_up_plane_normal(camera_quaternion, v_fov);
+    let down_plane_normal = this.get_down_plane_normal(camera_quaternion, v_fov);
+    let left_plane_normal = this.get_left_plane_normal(camera_quaternion, h_fov);
+    let right_plane_normal = this.get_right_plane_normal(camera_quaternion, h_fov);
+
+    let camera_forward_dir = new Vector3(0, 0, -1).applyQuaternion(camera_quaternion);
+
+    let sphere_center = this.sphere.center.clone();
+
+    let pull_back_distance = this.get_distance_to_fit_rect(this.sphere.radius * 2, this.sphere.radius * 2, vertical_fov, aspect);
+    let far_pos = sphere_center.clone().add(camera_forward_dir.clone().multiplyScalar(pull_back_distance * -1));
+
+    let up_plane    = new Plane().setFromNormalAndCoplanarPoint(up_plane_normal, far_pos);
+    let down_plane  = new Plane().setFromNormalAndCoplanarPoint(down_plane_normal, far_pos);
+
+    let left_plane   = new Plane().setFromNormalAndCoplanarPoint(left_plane_normal, far_pos);
+    let right_plane  = new Plane().setFromNormalAndCoplanarPoint(right_plane_normal, far_pos);
+
+    this.apply_center_correction_to_pos(far_pos, points, camera_quaternion, up_plane, down_plane, left_plane, right_plane);
+
+    up_plane.setFromNormalAndCoplanarPoint(up_plane_normal, far_pos);
+    down_plane.setFromNormalAndCoplanarPoint(down_plane_normal, far_pos);
+
+    left_plane.setFromNormalAndCoplanarPoint(left_plane_normal, far_pos);
+    right_plane.setFromNormalAndCoplanarPoint(right_plane_normal, far_pos);
+
+    let closest_distance = Infinity;
+
+    let inverse_dir = camera_forward_dir.clone().multiplyScalar(pull_back_distance * -2);
+    for (let i = 0; i < points.length; i++)
+    {
+      let line = new Line3(points[i].clone(), points[i].clone().add(inverse_dir));
+
+      let up_line_intersection  = new Vector3();
+      let down_line_intersection = new Vector3();
+
+      let left_line_intersection  = new Vector3();
+      let right_line_intersection = new Vector3();
+
+      up_plane.intersectLine(line,  up_line_intersection);
+      down_plane.intersectLine(line, down_line_intersection);
+
+      left_plane.intersectLine(line,  left_line_intersection);
+      right_plane.intersectLine(line, right_line_intersection);
+
+      if (up_line_intersection.length() < 0.0001)
+      {
+        console.log('up intersection not found', i);
+      }
+      if (down_line_intersection.length() < 0.0001)
+      {
+        console.log('down intersection not found', i);
+      }
+      if (left_line_intersection.length() < 0.0001)
+      {
+        console.log('left intersection not found', i);
+      }
+      if (right_line_intersection.length() < 0.0001)
+      {
+        console.log('right intersection not found', i);
+      }
+
+      let new_up_distance   = points[i].clone().sub(up_line_intersection).length();
+      let new_down_distance = points[i].clone().sub(down_line_intersection).length();
+
+      let new_left_distance   = points[i].clone().sub(left_line_intersection).length();
+      let new_right_distance  = points[i].clone().sub(right_line_intersection).length();
+
+      let vertical_min    = Math.min(new_up_distance, new_down_distance);
+      let horizontal_min  = Math.min(new_left_distance, new_right_distance);
+
+      let min = Math.min(vertical_min, horizontal_min);
+
+      if (min < closest_distance)
+      {
+        closest_distance = min;
+      }
+    }
+
+    let forward_correction = camera_forward_dir.clone().multiplyScalar(closest_distance);
+    let closest_position = far_pos.clone().add(forward_correction);
+
+    return closest_position;
+  }
+
+  apply_center_correction_to_pos(target_pos, points, camera_quaternion, up_plane, down_plane, left_plane, right_plane)
+  {
+    let vertical_offset = this.get_vertical_correction(points, down_plane, up_plane, camera_quaternion);
+    let horizontal_offset = this.get_hozirontal_correction(points, left_plane, right_plane, camera_quaternion);
+
+    target_pos.add(vertical_offset);
+    target_pos.add(horizontal_offset);
+  }
+
+  get_vertical_correction(points, down_plane, up_plane, camera_quaternion)
+  {
+    let closest_distance_to_up_plane = Infinity;
+    let closest_distance_to_down_plane  = Infinity;
+    let closest_up_point = undefined;
+    let closest_down_point = undefined;
+
+    let up_dir = new Vector3(0, 1, 0).applyQuaternion(camera_quaternion);
+    for (let i = 0; i < points.length; i++)
+    {
+      let down_line   = new Line3(points[i].clone(), points[i].clone().add(up_dir.clone().multiplyScalar(-5000000)));
+      let up_line     = new Line3(points[i].clone(), points[i].clone().add(up_dir.clone().multiplyScalar(5000000)));
+
+      let down_line_intersection  = new Vector3();
+      let up_line_intersection = new Vector3();
+
+      down_plane.intersectLine(down_line,  down_line_intersection);
+      up_plane.intersectLine(up_line, up_line_intersection);
+
+      let down_dist   = down_line_intersection.distanceTo(points[i]);
+      let up_dist     = up_line_intersection.distanceTo(points[i]);
+
+      if (up_line_intersection.length() < 0.0001)
+      {
+        console.log('vertical up intersection not found', i);
+      }
+      if (down_line_intersection.length() < 0.0001)
+      {
+        console.log('vertical down intersection not found', i);
+      }
+
+      if (down_dist < closest_distance_to_down_plane)
+      {
+        closest_distance_to_down_plane = down_dist;
+        closest_down_point = points[i];
+      }
+      if (up_dist < closest_distance_to_up_plane)
+      {
+        closest_distance_to_up_plane = up_dist;
+        closest_up_point = points[i];
+      }
+    }
+
+    console.log(closest_up_point, closest_down_point);
+
+    let correction = (closest_distance_to_up_plane - closest_distance_to_down_plane) / 2;
+
+    // console.log("vertical_correction", correction)
+    return up_dir.clone().multiplyScalar(-correction);
+  }
+
+  get_hozirontal_correction(points, left_plane, right_plane, camera_quaternion)
+  {
+    let closest_distance_to_right_plane = Infinity;
+    let closest_distance_to_left_plane  = Infinity;
+    let closest_right_point = undefined;
+    let closest_left_point = undefined;
+
+    let right_dir = new Vector3(1, 0, 0).applyQuaternion(camera_quaternion);
+
+    for (let i = 0; i < points.length; i++)
+    {
+      let left_line  = new Line3(points[i].clone(), points[i].clone().add(right_dir.clone().multiplyScalar(-5000000)));
+      let right_line = new Line3(points[i].clone(), points[i].clone().add(right_dir.clone().multiplyScalar(5000000)));
+
+      let left_line_intersection  = new Vector3();
+      let right_line_intersection = new Vector3();
+
+      left_plane.intersectLine(left_line,  left_line_intersection);
+      right_plane.intersectLine(right_line, right_line_intersection);
+
+      let left_dist  = left_line_intersection.distanceTo(points[i]);
+      let right_dist = right_line_intersection.distanceTo(points[i]);
+
+      if (left_line_intersection.length() < 0.0001)
+      {
+        console.log('left intersection not found', i);
+      }
+      if (right_line_intersection.length() < 0.0001)
+      {
+        console.log('right intersection not found', i);
+      }
+
+      if (left_dist < closest_distance_to_left_plane)
+      {
+        closest_distance_to_left_plane = left_dist;
+        closest_left_point = points[i];
+      }
+      if (right_dist < closest_distance_to_right_plane)
+      {
+        closest_distance_to_right_plane = right_dist;
+        closest_right_point = points[i];
+      }
+    }
+
+    let correction = (closest_distance_to_right_plane - closest_distance_to_left_plane) / 2;
+    // console.log("horizontal_correction", correction)
+
+    console.log(closest_right_point, closest_left_point);
+
+    return right_dir.clone().multiplyScalar(-correction);
+  }
+
+  get_up_plane_normal(camera_quaternion, v_fov)
+  {
+    let up_plane_normal = new Vector3(0, -1, 0);
+    up_plane_normal.applyQuaternion(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), v_fov));
+    up_plane_normal.applyQuaternion(camera_quaternion);
+    return up_plane_normal;
+  }
+
+  get_down_plane_normal(camera_quaternion, v_fov)
+  {
+    let down_plane_normal = new Vector3(0, 1, 0);
+    down_plane_normal.applyQuaternion(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -v_fov));
+    down_plane_normal.applyQuaternion(camera_quaternion);
+    return down_plane_normal;
+  }
+
+  get_left_plane_normal(camera_quaternion, h_fov)
+  {
+    let left_plane_normal = new Vector3(1, 0, 0);
+    left_plane_normal.applyQuaternion(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), h_fov));
+    left_plane_normal.applyQuaternion(camera_quaternion);
+    return left_plane_normal;
+  }
+
+  get_right_plane_normal(camera_quaternion, h_fov)
+  {
+    let right_plane_normal = new Vector3(-1, 0, 0);
+    right_plane_normal.applyQuaternion(new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), -h_fov));
+    right_plane_normal.applyQuaternion(camera_quaternion);
+    return right_plane_normal;
+  }
+
+  get_distance_to_fit_rect(width, height, vertical_fov, aspect)
+  {
+    let v_fov = (vertical_fov / 2) * Math.PI / 180;
+    let h_fov = (2 * Math.atan(Math.tan(v_fov) * aspect)) / 2;
+
+    let distV = height / Math.tan(v_fov);
+    let distH = width / Math.tan(h_fov);
+    return Math.max(Math.abs(distH), Math.abs(distV));
+  }
+}

package/src/utilities/GeometryUtilities.js

@@ -0,0 +1,74 @@
+import { BufferAttribute } from 'three';
+import { BufferGeometry } from 'three';
+
+export default class GeometryUtilities
+{
+  static convert_to_non_indexed_geometry(geometry_buffer)
+  {
+    let indices = geometry_buffer.index;
+    let positions = geometry_buffer.getAttribute('position');
+
+    let bar_coordinates = [];
+    let vertices = [];
+
+    for (let i = 0; i < indices.count; i += 3)
+    {
+      // VERTEX 1
+      vertices.push(positions.getX(indices.array[i + 0]));
+      vertices.push(positions.getY(indices.array[i + 0]));
+      vertices.push(positions.getZ(indices.array[i + 0]));
+
+      bar_coordinates.push(1);
+      bar_coordinates.push(0);
+      bar_coordinates.push(0);
+
+      // VERTEX 2
+
+      vertices.push(positions.getX(indices.array[i + 1]));
+      vertices.push(positions.getY(indices.array[i + 1]));
+      vertices.push(positions.getZ(indices.array[i + 1]));
+
+      bar_coordinates.push(0);
+      bar_coordinates.push(1);
+      bar_coordinates.push(0);
+
+      // VERTEX 3
+
+      vertices.push(positions.getX(indices.array[i + 2]));
+      vertices.push(positions.getY(indices.array[i + 2]));
+      vertices.push(positions.getZ(indices.array[i + 2]));
+
+      bar_coordinates.push(0);
+      bar_coordinates.push(0);
+      bar_coordinates.push(1);
+    }
+
+    let geometry = new BufferGeometry();
+    // geometry.setAttribute('barycentric', new BufferAttribute( new Float32Array(bar_coordinates), 3 ));
+    geometry.setAttribute('position', new BufferAttribute(new Float32Array(vertices), 3));
+    GeometryUtilities.add_barycentric_attribute(geometry);
+    return geometry;
+  }
+
+  static add_barycentric_attribute(non_indexed_geometry_buffer)
+  {
+    let bar_coordinates = [];
+    let positions = non_indexed_geometry_buffer.getAttribute('position');
+
+    for (let i = 0; i < positions.count; i += 3)
+    {
+      bar_coordinates.push(1);
+      bar_coordinates.push(0);
+      bar_coordinates.push(0);
+
+      bar_coordinates.push(0);
+      bar_coordinates.push(1);
+      bar_coordinates.push(0);
+
+      bar_coordinates.push(0);
+      bar_coordinates.push(0);
+      bar_coordinates.push(1);
+    }
+    non_indexed_geometry_buffer.setAttribute('barycentric', new BufferAttribute(new Float32Array(bar_coordinates), 3));
+  }
+}

package/src/utilities/ImageUtilities.js

@@ -0,0 +1,26 @@
+import { Vector4 } from 'three';
+
+export default class ImageUtilities
+{
+  constructor()
+  { }
+
+  static get_image_data(image)
+  {
+    let canvas = document.createElement('canvas');
+    canvas.width = image.width;
+    canvas.height = image.height;
+
+    let context = canvas.getContext('2d');
+    context.drawImage(image, 0, 0);
+
+    return context.getImageData(0, 0, image.width, image.height);
+  }
+
+  static get_pixel(imagedata, x, y)
+  {
+    let position = (x + imagedata.width * y) * 4;
+    let data = imagedata.data;
+    return new Vector4(data[position + 0], data[position + 1], data[position + 2], data[position + 3]);
+  }
+}

package/src/utilities/MathUtilities.js

@@ -0,0 +1,110 @@
+import { Vector3 } from 'three';
+import { Math as TMath } from 'three';
+
+export default class MathUtilities
+{
+  constructor()
+  {}
+
+  static linear_map(value,
+    from_range_start_value,
+    from_range_end_value,
+    to_range_start_value,
+    to_range_end_value)
+  {
+    return ((value - from_range_start_value) / (from_range_end_value - from_range_start_value)) * (to_range_end_value - to_range_start_value) + to_range_start_value;
+  }
+
+  static between(value, min, max)
+  {
+    return (value >= min && value <= max);
+  }
+
+  static mod(number, divisor)
+  {
+    return ((number % divisor) + divisor) % divisor;
+  }
+
+  static rgb_to_hex(rgb)
+  {
+    rgb.r = Math.round(rgb.r * 255).toString(16);
+    rgb.g = Math.round(rgb.g * 255).toString(16);
+    rgb.b = Math.round(rgb.b * 255).toString(16);
+
+    if (rgb.r.length === 1)
+    {
+      rgb.r = '0' + rgb.r;
+    }
+    if (rgb.g.length === 1)
+    {
+      rgb.g = '0' + rgb.g;
+    }
+    if (rgb.b.length === 1)
+    {
+      rgb.b = '0' + rgb.b;
+    }
+
+    return '#' + rgb.r + rgb.g + rgb.b;
+  }
+
+  static project_points_on_plane(points, plane)
+  {
+    let projected_point = new Vector3();
+    let points_on_plane = [];
+    for (let i = 0; i < points.length; i++)
+    {
+      plane.projectPoint(points[i], projected_point);
+      points_on_plane.push(projected_point.clone());
+    }
+
+    return points_on_plane;
+  }
+
+  static matrix4_lerp(from, to, target, t)
+  {
+    for (let i = 0; i < 16; i++)
+    {
+      target.elements[i] = TMath.lerp(from.elements[i], to.elements[i], t);
+    }
+  }
+
+  static equals(x1, x2)
+  {
+    return Math.abs(x1 - x2) < 0.000001;
+  }
+
+  static perspective_divide(v)
+  {
+    v.x /= v.w;
+    v.y /= v.w;
+    v.z /= v.w;
+    return v;
+  }
+
+  static points_average(points)
+  {
+    let center = points[0].clone();
+    for (let i = 1; i < points.length; i++)
+    {
+      center.add(points[i]);
+    }
+    center.multiplyScalar(1 / points.length);
+    return center;
+  }
+
+  static get_random_color()
+  {
+    let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', 'b', 'c', 'd', 'e', 'f'];
+
+    let col = '#';
+    col += arr[Math.floor(Math.random() * 16)];
+    col += arr[Math.floor(Math.random() * 16)];
+
+    col += arr[Math.floor(Math.random() * 16)];
+    col += arr[Math.floor(Math.random() * 16)];
+
+    col += arr[Math.floor(Math.random() * 16)];
+    col += arr[Math.floor(Math.random() * 16)];
+    return col;
+  }
+}

package/src/utilities/MeshSampler.js

@@ -0,0 +1,100 @@
+class MeshSampler
+{
+  constructor()
+  {
+
+  }
+
+  sample(geometry, sample_count)
+  {
+    let face_areas = [];
+
+    let min_area = 99999999;
+    for (let i = 0; i < geometry.faces.length; i++)
+    {
+      let area = this.get_face_area(geometry.faces[i], geometry.vertices);
+      min_area = Math.min(area, min_area);
+      face_areas.push(area);
+    }
+
+    let normalized_faces_array = this.get_uniform_face_distribution(face_areas, min_area, geometry.faces);
+    let selected_faces = this.select_random_faces(normalized_faces_array, sample_count);
+    let sampled_data = this.sample_data_from_faces(selected_faces, geometry.vertices);
+    return sampled_data;
+  }
+
+  sample_data_from_faces(faces, vertices)
+  {
+    let sampled_points = [];
+    let sampled_normals = [];
+    for (let i = 0; i < faces.length; i++)
+    {
+      let face = faces[i];
+
+      let w1 = Math.random();
+      let w2 = Math.random();
+
+      sampled_points.push(this.sample_point_in_face(w1, w2, vertices[face.a], vertices[face.b], vertices[face.c]).clone());
+      if (sampled_normals && face.normal)
+      {
+        sampled_normals.push(face.normal.clone());
+      }
+    }
+    return { points: sampled_points, normals: sampled_normals };
+  }
+
+  select_random_faces(faces, amount)
+  {
+    let selected_faces = [];
+    for (let i = 0; i < amount; i++)
+    {
+      let random = parseInt(Math.random() * (faces.length - 1));
+      let selected_face = faces[random];
+
+      selected_faces.push(selected_face);
+    }
+
+    return selected_faces;
+  }
+
+  get_uniform_face_distribution(face_areas, minimum_area, faces)
+  {
+    let extended_triangle_indices = [];
+    for (let i = 0; i < face_areas.length; i++)
+    {
+      face_areas[i] /= minimum_area;
+      let repetitions_needed = parseInt(Math.round(face_areas[i]));
+      for (let j = 0; j < repetitions_needed; j++)
+      {
+        extended_triangle_indices.push(faces[i]);
+      }
+    }
+    return extended_triangle_indices;
+  }
+
+  get_face_area(face, vertices)
+  {
+    let v1 = vertices[face.a].clone();
+    let v2 = vertices[face.b].clone();
+    let v3 = vertices[face.c].clone();
+
+    let vec1 = v2.clone().sub(v1);
+    let vec2 = v3.clone().sub(v1);
+    return vec1.cross(vec2).length() / 2;
+  }
+
+  sample_point_in_face(w1, w2, v1, v2, v3)
+  {
+    if (w1 + w2 > 1)
+    {
+      w1 = 1.0 - w1;
+      w2 = 1.0 - w2;
+    }
+
+    let w3 = 1.0 - (w1 + w2);
+
+    return v1.clone().multiplyScalar(w1).add(v2.clone().multiplyScalar(w2)).add(v3.clone().multiplyScalar(w3));
+  }
+}
+
+export default new MeshSampler();