Ejemplo n.º 1
0
     perspective_data['a_color'] = np.reshape(np.array(ori_pano), (pano_height*pano_width, 3))
     tri = np.zeros((pano_height*pano_width*2, 3), dtype=np.uint32)
     tri_idx = 0
     for y in range(0, pano_height-1):
         for x in range(pano_width-1):
             cur = y*pano_width + x
             tri[tri_idx] = [cur, cur+1, cur+pano_width]
             tri[tri_idx+pano_height*pano_width] = [cur + pano_width, cur + 1, cur + pano_width + 1]
             tri_idx += 1
     for y in range(0, pano_height-1):
         cur = y * pano_width + pano_width - 1
         tri[tri_idx] = [cur, cur-pano_width+1, cur+pano_width]
         tri[tri_idx+pano_height*pano_width] = [cur+pano_width, cur-pano_width+1, cur+1]
         tri_idx += 1
     # TODO: top and bottom
     programPerspective = glumpy_setting.ProgramPlane(data=perspective_data, name='perspective',
                                                      face=tri)
 else:
     programSV3DRegion = glumpy_setting.ProgramSV3DRegion(
         data=data, name='programSV3DRegion', point_size=1,
         anchor_matrix=sv3DRegion.anchorMatrix, anchor_yaw=sv3DRegion.anchorYaw, is_inverse=needMatchInfo3d)
     programSV3DRegionGnd = glumpy_setting.ProgramSV3DRegion(
         data=dataGnd, name='programSV3DRegionGnd', point_size=1,
         anchor_matrix=sv3DRegion.anchorMatrix, anchor_yaw=sv3DRegion.anchorYaw, is_inverse=needMatchInfo3d)
     programSV3DTopology = glumpy_setting.ProgramSV3DTopology(
         data=sv3DRegion.topologyData, name='programSV3DTopology',
         anchor_matrix=sv3DRegion.anchorMatrix, anchor_yaw=sv3DRegion.anchorYaw, is_inverse=needMatchInfo3d)
     if imageSynthesis:
         programSV3DNearest = glumpy_setting.ProgramSV3DTopology(
             data=dataNearest, name='programSV3DNearest',
             anchor_matrix=sv3DRegion.anchorMatrix, anchor_yaw=sv3DRegion.anchorYaw, is_inverse=needMatchInfo3d,
             point_size=20, alpha=0.6)
Ejemplo n.º 2
0
                    img_x = int(lng / 360.0 * 512.0)
                    img_y = int(-(lat - 90) / 180.0 * 256.0)
                    syn_pano[img_y, img_x, :] = point['a_color']
                    index_pano[img_y, img_x] = True

                    yo_xyz.append([img_x, img_y, 0])
                    yo_color.append(point['a_color'])
                    yo_len += 1

        show_pano = np.concatenate((ori_pano, syn_pano), axis=1)
        #scipy.misc.imsave('yo.png', syn_pano)
        scipy.misc.imshow(show_pano)

        data = np.zeros((yo_len),
                        dtype=[('a_position', np.float32, 3),
                               ('a_color', np.float32, 3)])
        data['a_color'] = np.array(yo_color)
        data['a_position'] = np.array(yo_xyz)

        pca = PCA(n_components=2)
        data_transfer = pca.fit_transform(data['a_position'])
        tri = np.array(triangle.delaunay(data_transfer), dtype=np.uint32)
        programImage = glumpy_setting.ProgramPlane(data=data,
                                                   name='test',
                                                   face=tri)
        data['a_position'][:, 0] = data['a_position'][:, 0] / 256.0 - 1.0
        data['a_position'][:, 1] = data['a_position'][:, 1] / 128.0 - 1.0

gpyViewWindow = glumpy_setting.GpyViewWindow(data, tri)
gpyViewWindow.run()
Ejemplo n.º 3
0
        index += 1
        if index > 0:
            break
        #break

gpyWindow = glumpy_setting.GpyWindow()

programSV3DRegion = glumpy_setting.ProgramSV3DRegion(
    data=data, name=None, point_size=1, anchor_matrix=anchor_matrix_whole)
programSV3DRegion.apply_anchor()
#gpyWindow.add_program(programSV3DRegion)

data = programSV3DRegion.data
tri = np.array(triangle.delaunay(data['a_position'][:, 0:2]), dtype=np.uint32)
programGround = glumpy_setting.ProgramPlane(data=data,
                                            name=str(index),
                                            face=tri)
gpyWindow.add_program(programGround)
"""
ALL PLY EXPORT IN HERE
"""

data = programSV3DRegion.data
data['a_color'] *= 255
data['a_color'].astype(int)

xyzzz = np.zeros(len(data),
                 dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4'), ('red', 'u1'),
                        ('green', 'u1'), ('blue', 'u1')])
xyzzz['x'] = data['a_position'][:, 0]
xyzzz['y'] = data['a_position'][:, 1]
Ejemplo n.º 4
0
"""
For Visualize
"""
if needVisual:
    gpyWindow = glumpy_setting.GpyWindowVR(window_height=256, window_width=512)
    if createSFM:
        gpyWindow.add_program(programSFM3DRegion)
        gpyWindow.add_program(programTrajectory)

    if createSV:
        if addPlane:
            for j in range(0, pano_length):
                sv3D = sv3DRegion.sv3D_Time[j]
                for i in range(0, len(sv3D.all_plane)):
                    programGround = glumpy_setting.ProgramPlane(
                        data=sv3D.all_plane[i]['data'],
                        name='test',
                        face=sv3D.all_plane[i]['tri'])
                    gpyWindow.add_program(programGround)
        else:
            gpyWindow.add_program(programSV3DRegion)
            gpyWindow.add_program(programSV3DTopology)
            if imageSynthesis:
                gpyWindow.add_program(programSV3DNearest)
            if needGround:
                gpyWindow.add_program(programSV3DRegionGnd)

    programAxis = glumpy_setting.ProgramAxis(line_length=5)
    gpyWindow.add_program(programAxis)

    gpyWindow.run()
Ejemplo n.º 5
0
                        for ppx in range(0, pp_width * pp_dense):
                            x, y, z = (ppx/pp_dense) - (0.5 * pp_width), pp_depth, (ppy/pp_dense) - (0.5 * pp_height)
                            lng, lat = base_process.pos_2_deg(x, y, z)

                            lng = (lng + randomDeg) % 360
                            img_x = int(lng / 360.0 * 512.0)
                            img_y = int(-(lat - 90) / 180.0 * 256.0)
                            # plane_pano[ppy, ppx, :] = ori_pano[img_y, img_x, :]
                            plane_data[pp_index]['a_position'] = [x, y, z]
                            plane_data[pp_index]['a_color'] = ori_pano[img_y, img_x, :]
                            pp_index += 1

                    pca = PCA(n_components=2)
                    data_transfer = pca.fit_transform(plane_data['a_position'])
                    tri = np.array(triangle.delaunay(data_transfer), dtype=np.uint32)
                    programImage = glumpy_setting.ProgramPlane(data=plane_data, name='test',
                                                               face=tri)



        #show_pano = np.concatenate((ori_pano, syn_pano), axis=1)
        #scipy.misc.imsave('yo.png', syn_pano)
        #scipy.misc.imshow(plane_pano)
        if needVisual:
            programSV3DRegion = glumpy_setting.ProgramSV3DRegion(
                data=data, name='programSV3DRegion',
                anchor_matrix=sv3DRegion.anchorMatrix, anchor_yaw=sv3DRegion.anchorYaw, is_inverse=needMatchInfo3d)
            programSV3DRegionGnd = glumpy_setting.ProgramSV3DRegion(
                data=dataGnd, name='programSV3DRegionGnd',
                anchor_matrix=sv3DRegion.anchorMatrix, anchor_yaw=sv3DRegion.anchorYaw, is_inverse=needMatchInfo3d)
            programSV3DTopology = glumpy_setting.ProgramSV3DTopology(
                data=sv3DRegion.topologyData, name='programSV3DTopology',
Ejemplo n.º 6
0
color = np.zeros((size, 3), dtype=np.float32)
for y in range(0, ny):
    for x in range(0, nx):
        index = x + y * ny
        pos = plane[index]
        color[index] = [1, 0, 0]

data = np.zeros((nx * ny),
                dtype=[('a_position', np.float32, 3),
                       ('a_color', np.float32, 3)])
data['a_position'] = plane
data['a_color'] = color

#I = np.array([0, 1, 2, 0, 2, 3], dtype=np.uint32)
tri = np.array(triangle.delaunay(data['a_position'][:, 0:2]), dtype=np.uint32)
programGround = glumpy_setting.ProgramPlane(data=data, name='test', face=tri)
"""
For Visualize
"""
if needVisual:
    gpyWindow = glumpy_setting.GpyWindow()

    gpyWindow.add_program(programGround)

    if createSV:
        gpyWindow.add_program(programSV3DRegion)
        gpyWindow.add_program(programSV3DTopology)
        if needGround:
            gpyWindow.add_program(programSV3DRegionGnd)

    programAxis = glumpy_setting.ProgramAxis(line_length=5)
Ejemplo n.º 7
0
        programSV3D = glumpy_setting.ProgramSV3D(data=sv3D.ptCLoudData,
                                                 name=str(index),
                                                 point_size=1)
        programSV3D.u_model = np.eye(4, dtype=np.float32)
        ##reset

        #yo = np.where(sv3D.ptCLoudData['a_position'][:, :, 2] < 1)
        match = sv3D.ptCLoudData[sv3D.ptCLoudData['a_position'][:, :, 2] < -1]
        match['a_position'][:, 2] = -2
        #match = sv3D.ptCLoudData['a_color'][sv3D.ptCLoudData['a_position'][:, :, 2] < 1]
        #gpyWindow.add_program(programSV3D)
        index += 1
        break

#programAxis = glumpy_setting.ProgramAxis(line_length=5)
#gpyWindow.add_program(programAxis)

#match_data = np.zeros(len(match), dtype=[('a_position', np.float32, 3), ('a_color', np.float32, 3)])
#match_data['a_position'] = match
#match_data['a_color'] = [1,0,0]

tri = np.array(triangle.delaunay(match['a_position'][:, 0:2]), dtype=np.uint32)
tri = tri.view(gloo.IndexBuffer)

matchProgram = glumpy_setting.ProgramPlane(data=match,
                                           name=str(index),
                                           face=tri)
gpyWindow.add_program(matchProgram)

gpyWindow.run()