def castalia_reconstruction(img_path):
"""Incrementally modify an ellipse into a low resolution verision of castalia
by adding vertices and modifying the mesh
"""
surf_area = 0.01
a = 0.22
delta = 0.01
# load a low resolution ellipse to start
ast = asteroid.Asteroid('castalia', 0, 'obj')
ellipsoid = surface_mesh.SurfMesh(ast.axes[0], ast.axes[1], ast.axes[2],
10, 0.025, 0.5)
ve, fe = ellipsoid.verts(), ellipsoid.faces()
vc, fc = ast.V, ast.F
# sort the vertices in in order (x component)
vc = vc[vc[:, 0].argsort()]
# uncertainty for each vertex in meters (1/variance)
vert_weight = np.full(ve.shape[0], (np.pi * np.max(ast.axes))**2)
# calculate maximum angle as function of surface area
max_angle = wavefront.spherical_surface_area(np.max(ast.axes), surf_area)
# loop and create many figures
mfig = graphics.mayavi_figure(offscreen=False)
mesh = graphics.mayavi_addMesh(mfig, ve, fe)
ms = mesh.mlab_source
index = 0
for ii, pt in enumerate(vc):
index += 1
filename = os.path.join(
img_path, 'castalia_reconstruct_' + str(index).zfill(7) + '.jpg')
# graphics.mlab.savefig(filename, magnification=4)
ve, vert_weight = wavefront.spherical_incremental_mesh_update(
pt, ve, fe, vertex_weight=vert_weight, max_angle=max_angle)
ms.reset(x=ve[:, 0], y=ve[:, 1], z=ve[:, 2], triangles=fe)
graphics.mayavi_addPoint(mfig, pt, radius=0.01)
graphics.mayavi_points3d(mfig, ve, scale_factor=0.01, color=(1, 0, 0))
return 0
from kinematics import attitude
import numpy as np
import scipy.io
import pdb
# load data from sphere and ellipsoid
sphere_data = scipy.io.loadmat('./data/sphere_distmesh.mat')
ellipsoid_data = scipy.io.loadmat('./data/ellipsoid_distmesh.mat')
vs, fs = sphere_data['v'], sphere_data['f']
ve, fe = ellipsoid_data['v'], ellipsoid_data['f']
# now use cgal
sphere = surface_mesh.SurfMesh(0.5, 0.5, 0.5, 10, 0.015, 0.5)
ellipsoid = surface_mesh.SurfMesh(1, 2, 3, 10, 0.06, 0.5)
print("Some statisitics")
print("Distmesh Sphere: Vertices: {} Faces: {}".format(vs.shape[0],
fs.shape[0]))
print("Distmesh Ellipsoid: Vertices: {} Faces: {}".format(
ve.shape[0], fe.shape[0]))
print("SurfMesh Sphere: Vertices: {} Faces: {}".format(
sphere.verts().shape[0],
sphere.faces().shape[0]))
print("SurfMesh Ellipsoid: Vertices: {} Faces: {}".format(
ellipsoid.verts().shape[0],
ellipsoid.faces().shape[0]))
mfig_distmesh = graphics.mayavi_figure()
def asteroid_reconstruct_generate_data(output_filename,
asteroid_name='castalia'):
"""Generate all the data for an example for reconstructing asteroid
"""
asteroid_type = 'obj'
asteroid_faces = 0
if asteroid_name == 'castalia':
ellipsoid_min_angle = 10
ellipsoid_max_radius = 0.03
ellipsoid_max_distance = 0.5
step = 1
surf_area = 0.01
elif asteroid_name == 'itokawa':
ellipsoid_min_angle = 10
ellipsoid_max_radius = 0.003
ellipsoid_max_distance = 0.5
step = 1
surf_area = 0.0001
# load asteroid castalia
ast = asteroid.Asteroid(asteroid_name, asteroid_faces, asteroid_type)
ellipsoid = surface_mesh.SurfMesh(ast.axes[0], ast.axes[1], ast.axes[2],
ellipsoid_min_angle,
ellipsoid_max_radius,
ellipsoid_max_distance)
ve, fe = ellipsoid.verts(), ellipsoid.faces()
vc, fc = ast.V, ast.F
# cort the truth vertices in increasing order of x component
vc = vc[vc[:, 0].argsort()]
vc = vc[::step, :]
# np.random.shuffle(vc)
# define initial uncertainty for our estimate
vert_weight = np.full(ve.shape[0], (np.pi * np.max(ast.axes))**2)
# calculate the maximum angle as a function of desired surface area
max_angle = wavefront.spherical_surface_area(np.max(ast.axes), surf_area)
# generate a mesh and reconstruct object from c++
mesh = mesh_data.MeshData(ve, fe)
rmesh = reconstruct.ReconstructMesh(ve, fe, vert_weight)
# loop over all the points and save the data
output_path = os.path.join(output_filename)
with h5py.File(output_path, 'w') as fout:
reconstructed_vertex = fout.create_group('reconstructed_vertex')
reconstructed_weight = fout.create_group('reconstructed_weight')
reconstructed_vertex.attrs['asteroid_name'] = np.string_(asteroid_name)
reconstructed_vertex.attrs['asteroid_faces'] = asteroid_faces
reconstructed_vertex.attrs['asteroid_type'] = np.string_(asteroid_type)
reconstructed_vertex.attrs['ellipsoid_axes'] = ast.axes
reconstructed_vertex.attrs['ellipsoid_min_angle'] = ellipsoid_min_angle
reconstructed_vertex.attrs[
'ellipsoid_max_radius'] = ellipsoid_max_radius
reconstructed_vertex.attrs[
'ellipsoid_max_distance'] = ellipsoid_max_distance
reconstructed_vertex.attrs['surf_area'] = surf_area
fout.create_dataset('truth_vertex', data=vc)
fout.create_dataset('truth_faces', data=fc)
fout.create_dataset('estimate_faces', data=fe)
fout.create_dataset('initial_vertex', data=ve)
fout.create_dataset('initial_faces', data=fe)
fout.create_dataset('initial_weight', data=vert_weight)
for ii, pt in enumerate(vc):
# ve, vert_weight = wavefront.spherical_incremental_mesh_update(pt, ve, fe,
# vertex_weight=vert_weight,
# max_angle=max_angle)
rmesh.update(pt, max_angle)
ve = rmesh.get_verts()
vert_weight = np.squeeze(rmesh.get_weights())
# save the current array and weight to htpy
reconstructed_vertex.create_dataset(str(ii),
data=ve,
compression='lzf')
reconstructed_weight.create_dataset(str(ii),
data=vert_weight,
compression='lzf')
print('Finished generating data. Saved to {}'.format(output_path))
return 0
def incremental_reconstruction(input_filename,
output_filename,
asteroid_name='castalia'):
"""Incrementally update the mesh
Now we'll use the radial mesh reconstruction.
"""
logger = logging.getLogger(__name__)
# output_filename = './data/raycasting/20180226_castalia_reconstruct_highres_45deg_cone.hdf5'
logger.info('Loading {}'.format(input_filename))
data = np.load(input_filename)
point_cloud = data['point_cloud'][()]
# define the asteroid and dumbbell objects
asteroid_faces = 0
asteroid_type = 'obj'
m1, m2, l = 500, 500, 0.003
ellipsoid_min_angle = 10
ellipsoid_max_radius = 0.03
ellipsoid_max_distance = 0.5
surf_area = 0.01
ast = asteroid.Asteroid(asteroid_name, asteroid_faces, asteroid_type)
dum = dumbbell.Dumbbell(m1=m1, m2=m2, l=l)
logger.info('Creating ellipsoid mesh')
# define a simple mesh to start
ellipsoid = surface_mesh.SurfMesh(ast.axes[0], ast.axes[1], ast.axes[2],
ellipsoid_min_angle,
ellipsoid_max_radius,
ellipsoid_max_distance)
v_est, f_est = ellipsoid.verts(), ellipsoid.faces()
vert_weight = np.full(v_est.shape[0], (np.pi * np.max(ast.axes))**2)
max_angle = wavefront.spherical_surface_area(np.max(ast.axes), surf_area)
# extract out all the points in the asteroid frame
time = point_cloud['time'][::1]
ast_ints = point_cloud['ast_ints'][::1]
logger.info('Create HDF5 file {}'.format(output_filename))
with h5py.File(output_filename, 'w') as fout:
# store some extra data about teh simulation
v_group = fout.create_group('reconstructed_vertex')
f_group = fout.create_group('reconstructed_face')
w_group = fout.create_group('reconstructed_weight')
sim_data = fout.create_group('simulation_data')
sim_data.attrs['asteroid_name'] = np.string_(asteroid_name)
sim_data.attrs['asteroid_faces'] = asteroid_faces
sim_data.attrs['asteroid_type'] = np.string_(asteroid_type)
sim_data.attrs['m1'] = dum.m1
sim_data.attrs['m2'] = dum.m2
sim_data.attrs['l'] = dum.l
sim_data.attrs['ellipsoid_axes'] = ast.axes
sim_data.attrs['ellipsoid_min_angle'] = ellipsoid_min_angle
sim_data.attrs['ellipsoid_max_radius'] = ellipsoid_max_radius
sim_data.attrs['ellipsoid_max_distance'] = ellipsoid_max_distance
sim_data.attrs['surf_area'] = surf_area
sim_data.attrs['max_angle'] = max_angle
fout.create_dataset('truth_vertex', data=ast.V)
fout.create_dataset('truth_faces', data=ast.F)
fout.create_dataset('estimate_faces', data=f_est)
fout.create_dataset('initial_vertex', data=v_est)
fout.create_dataset('initial_faces', data=f_est)
fout.create_dataset('initial_weight', data=vert_weight)
logger.info('Starting loop over point cloud')
for ii, (t, points) in enumerate(zip(time, ast_ints)):
# check if points is empty
logger.info('Current : t = {} with {} points'.format(
t, len(points)))
for pt in points:
# incremental update for each point in points
# check to make sure each pt is not nan
if not np.any(np.isnan(pt)):
v_est, vert_weight = wavefront.spherical_incremental_mesh_update(
pt,
v_est,
f_est,
vertex_weight=vert_weight,
max_angle=max_angle)
# use HD5PY instead
# save every so often and delete v_array,f_array to save memory
if (ii % 1) == 0:
logger.info('Saving data to HDF5. ii = {}, t = {}'.format(
ii, t))
v_group.create_dataset(str(ii), data=v_est)
f_group.create_dataset(str(ii), data=f_est)
w_group.create_dataset(str(ii), data=vert_weight)
logger.info('Completed the reconstruction')
return 0
"""Uniform mesh plots for dissertation Some examples of variations in a initial mesh estimate for the paper Author ------ Shankar Kulumani GWU [email protected] """ import numpy as np from lib import surface_mesh from visualization import graphics # generate two triaxial ellipsoids smesh_1 = surface_mesh.SurfMesh(1, 0.5, 0.5, 10, 0.2, 0.1) smesh_2 = surface_mesh.SurfMesh(1, 0.5, 0.5, 10, 0.1, 0.1) view =(45.00000000000001, 54.73561031724535, 2.705956013687095, np.array([ 0.12708219, -0.05595058, -0.07152687])) mfig = graphics.mayavi_figure(offscreen=False) mesh = graphics.mayavi_addMesh(mfig, smesh_1.get_verts(), smesh_1.get_faces(), representation='wireframe') graphics.mlab.view(*view) graphics.mlab.savefig('/tmp/uniform_mesh_coarse.jpg', magnification=4) ms = mesh.mlab_source ms.reset(x=smesh_2.get_verts()[:, 0], y=smesh_2.get_verts()[:, 1], z=smesh_2.get_verts()[:, 2], triangles=smesh_2.get_faces()) graphics.mlab.view(*view)
"""Test out creating and plotting a geodesic waypoint (great circle) on the
sphere
"""
from point_cloud import wavefront
from kinematics import sphere
from visualization import graphics
from lib import geodesic, surface_mesh
import numpy as np
# generate a sphere for plotting
sphere_mesh = surface_mesh.SurfMesh(1, 1, 1, 10, 0.15, 0.5)
vs, fs = sphere_mesh.verts(), sphere_mesh.faces()
# create two random points on the sphere
initial_point_cartesian = sphere.rand(2)
final_point_cartesian = sphere.rand(2)
# compute waypoints inbetween
waypoints_cartesian = geodesic.sphere_waypoint(initial_point_cartesian,
final_point_cartesian, 5)
# plot everythign on a mayavi figure
mfig = graphics.mayavi_figure()
graphics.mayavi_axes(mfig, [-1, 1, -1, 1, -1, 1])
graphics.mayavi_addMesh(mfig, vs, fs, color=(0, 0, 1), opacity=0.2)
graphics.mayavi_points3d(mfig, waypoints_cartesian, color=(0, 0, 1))
graphics.mayavi_addPoint(mfig, initial_point_cartesian, color=(0, 1, 0))
graphics.mayavi_addPoint(mfig, final_point_cartesian, color=(1, 0, 0))