def main(argv): parser = argparse.ArgumentParser( description="Generate a cuboid dataset" ) parser.add_argument( "output_directory", help="Save the dataset in this directory" ) parser.add_argument( "--n_samples", type=int, default=10, help="Number of training samples to be generated" ) parser.add_argument( "--max_n_shapes_per_samples", type=int, default=4, help="Number of shapes per sample" ) args = parser.parse_args(argv) # Check if output directory exists and if it doesn't create it if not os.path.exists(args.output_directory): os.makedirs(args.output_directory) # Create a directory based on the type of the shapes inside the output # directory output_directory = os.path.join( args.output_directory, "spheres_dataset" ) print "Saving models to %s" % (output_directory,) prog = Progbar(args.n_samples) for i in range(args.n_samples): prims = build_sequentially_attaching_sheres( np.random.choice(np.arange(2, args.max_n_shapes_per_samples)) ) c = Shape.from_shapes(prims) # Create subdirectory to save the sample base_dir = os.path.join(output_directory, "%05d" % (i,), "models") if not os.path.exists(base_dir): os.makedirs(base_dir) # print base_dir # Save as obj file c.save_as_mesh(os.path.join(base_dir, "model_normalized.obj"), "obj") c.save_as_mesh(os.path.join(base_dir, "model_normalized.ply"), "ply") c.save_as_pointcloud( os.path.join(base_dir, "model_normalized_pcl.obj"), "obj" ) prog.update(i + 1)
def main(argv): parser = argparse.ArgumentParser( description="Generate a cuboid dataset" ) parser.add_argument( "output_directory", help="Save the dataset in this directory" ) parser.add_argument( "--n_samples", type=int, default=10, help="Number of training samples to be generated" ) parser.add_argument( "--shapes_type", default="cubes", choices=[ "cubes", "cubes_translated", "cubes_rotated_translated", "cubes_rotated", "rectangles", "rectangles_translated", "rectangles_rotated", "rectangles_rotated_translated", "ellipsoid", "random" ], help="The type of the shapes in every sample" ) parser.add_argument( "--n_shapes_per_samples", type=int, default=1, help="Number of shapes per sample" ) parser.add_argument( "--maximum", type=lambda x: tuple(map(float, x.split(","))), default="0.5,0.5,0.5", help="Maximum size along every axis" ) parser.add_argument( "--minimum", type=lambda x: tuple(map(float, x.split(","))), default="0.13,0.13,0.13", help="Maximum size along every axis" ) args = parser.parse_args(argv) # Check if output directory exists and if it doesn't create it if not os.path.exists(args.output_directory): os.makedirs(args.output_directory) # Create a directory based on the type of the shapes inside the output # directory output_directory = os.path.join( args.output_directory, args.shapes_type ) ranges = None if "cubes" in args.shapes_type: # Make sure that the maximum and minimum range are equal along each # axis assert args.maximum[0] == args.maximum[1] assert args.maximum[1] == args.maximum[2] assert args.minimum[0] == args.minimum[1] assert args.minimum[1] == args.minimum[2] ranges = np.linspace( args.minimum[0], args.maximum[0], 10, endpoint=False ) # elif "rectangles" in args.shapes_type: else: ranges = [ np.linspace(args.minimum[0], args.maximum[0], 10, endpoint=False), np.linspace(args.minimum[1], args.maximum[1], 10, endpoint=False), np.linspace(args.minimum[2], args.maximum[2], 10, endpoint=False), ] bar = Bar("Generating %d cuboids" % (args.n_samples,), max=args.n_samples) c = None for i in range(args.n_samples): if "cubes" in args.shapes_type: c = get_single_cube(args.minimum, args.maximum) if "rectangles" in args.shapes_type: c = get_single_rectangle(args.minimum, args.maximum) if "translated" in args.shapes_type: t = 0.3*np.random.random((3, 1)) c.translate(t) if "rotated" in args.shapes_type: q = Quaternion.random() R = q.rotation_matrix c.rotate(R) if "ellipsoid" in args.shapes_type: abc = np.random.random((3, 1)) c1 = Ellipsoid(abc[0], abc[1], abc[2]) c2 = Ellipsoid(abc[0], abc[1], abc[2]) c3 = Ellipsoid(abc[0], abc[1], abc[2]) q = Quaternion.random() R = q.rotation_matrix c2.rotate(R) q = Quaternion.random() R = q.rotation_matrix c3.rotate(R) # t = 0.3*np.random.random((3, 1)) # c1.translate(t) c = Shape.from_shapes([c1, c2, c3]) if "random" in args.shapes_type: #if random.choice((True, False)): #if True: # q = Quaternion.random() # c1, c2 = adjacent_cubes(q.rotation_matrix) #else: if True: q1 = Quaternion.random() q2 = Quaternion.random() c1, c2 = multiple_cubes( q1.rotation_matrix, q2.rotation_matrix, 3.5*np.random.random((3, 1)) ) # q = Quaternion.random() # c1, c2 = adjacent_cubes(q.rotation_matrix) # q1 = Quaternion.random() # x_max1, y_max1, z_max1 = tuple(np.random.rand(3)) # c3 = Cuboid(-x_max1, x_max1, -y_max1, y_max1, -z_max1, z_max1) # c3.rotate(q1.rotation_matrix) # c3.translate(np.random.random((3,1)).reshape(3, -1)) c = Shape.from_shapes([c1, c2]) # Create subdirectory to save the sample folder_name = ''.join([ random.choice(ascii_letters + digits) for n in xrange(32) ]) base_dir = os.path.join(output_directory, folder_name, "models") if not os.path.exists(base_dir): os.makedirs(base_dir) # print base_dir # Save as obj file c.save_as_mesh(os.path.join(base_dir, "model_normalized.obj"), "obj") c.save_as_mesh(os.path.join(base_dir, "model_normalized.ply"), "ply") c.save_as_pointcloud( os.path.join(base_dir, "model_normalized_pcl.obj"), "obj" ) if "translated" in args.shapes_type: print os.path.join(base_dir, "model_normalized_pcl.obj"), t.T if "rotated" in args.shapes_type: print os.path.join(base_dir, "model_normalized_pcl.obj"), q bar.next() for i in os.listdir(output_directory): x = os.path.join(output_directory, i, "models/model_normalized.obj") m = MeshFromOBJ(x) print x, m.points.max(-1)
return (p_max - p_min) / 2 + p_min def get_rectangle(cube, T, **kwargs): corner1 = cube.points[:, 0] corner2 = cube.points[:, -1] return Rectangle(corner1 - T, *(corner2 - corner1), **kwargs) if __name__ == "__main__": c1, c2, y_hat = cubes_inside(0.2, 0.2, 0.1, 0.1, 0.1, 0.1) T = get_translation([c1, c2]) probs, translations, quats, shapes, epsilons = y_hat c = Shape.from_shapes([c1, c2]) c.save_as_mesh("/tmp/mesh.obj", "obj") m = MeshFromOBJ("/tmp/mesh.obj") y_target = torch.from_numpy(m.sample_faces(1000).astype( np.float32)).float().unsqueeze(0) # A sampler instance e = EqualDistanceSamplerSQ(200) # Compute the loss for the current experiment l_weights = { "coverage_loss_weight": 1.0, "consistency_loss_weight": 1.0, } reg_terms = { "regularizer_type": [], "shapes_regularizer_weight": 0.0,