a b/Data/Tests_data/3d-mnist/plot3D.py 

  1
  





  
  

  2
  
import numpy as np





  
  

  3
  
from IPython.display import IFrame





  
  

  4
  
from matplotlib import pyplot as plt





  
  

  5
  





  
  

  6
  





  
  

  7
  





  
  

  8
  
def array_to_color(array, cmap="Oranges"):





  
  

  9
  
    s_m = plt.cm.ScalarMappable(cmap=cmap)





  
  

  10
  
    return s_m.to_rgba(array)[:,:-1]





  
  

  11
  





  
  

  12
  





  
  

  13
  
TEMPLATE_POINTS = """





  
  

  14
  
<!DOCTYPE html>





  
  

  15
  
<head>





  
  

  16
  





  
  

  17
  
<title>PyntCloud</title>





  
  

  18
  
<meta charset="utf-8">





  
  

  19
  
<meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">





  
  

  20
  
<style>





  
  

  21
  
body {{





  
  

  22
  
    color: #cccccc;





  
  

  23
  
    font-family: Monospace;





  
  

  24
  
    font-size: 13px;





  
  

  25
  
    text-align: center;





  
  

  26
  
    background-color: #050505;





  
  

  27
  
    margin: 0px;





  
  

  28
  
    overflow: hidden;





  
  

  29
  
}}





  
  

  30
  
#logo_container {{





  
  

  31
  
    position: absolute;





  
  

  32
  
    top: 0px;





  
  

  33
  
    width: 100%;





  
  

  34
  
}}





  
  

  35
  
.logo {{





  
  

  36
  
    max-width: 20%;





  
  

  37
  
}}





  
  

  38
  
</style>





  
  

  39
  





  
  

  40
  
</head>





  
  

  41
  
<body>





  
  

  42
  





  
  

  43
  
<div>





  
  

  44
  
    <img class="logo" src="https://media.githubusercontent.com/media/daavoo/pyntcloud/master/docs/data/pyntcloud.png">





  
  

  45
  
</div>





  
  

  46
  





  
  

  47
  
<div id="container">





  
  

  48
  
</div>





  
  

  49
  





  
  

  50
  
<script src="http://threejs.org/build/three.js"></script>





  
  

  51
  
<script src="http://threejs.org/examples/js/Detector.js"></script>





  
  

  52
  
<script src="http://threejs.org/examples/js/controls/OrbitControls.js"></script>





  
  

  53
  
<script src="http://threejs.org/examples/js/libs/stats.min.js"></script>





  
  

  54
  





  
  

  55
  
<script>





  
  

  56
  





  
  

  57
  
    if ( ! Detector.webgl ) Detector.addGetWebGLMessage();





  
  

  58
  





  
  

  59
  
    var container, stats;





  
  

  60
  
    var camera, scene, renderer;





  
  

  61
  
    var points;





  
  

  62
  





  
  

  63
  
    init();





  
  

  64
  
    animate();





  
  

  65
  





  
  

  66
  
    function init() {{





  
  

  67
  





  
  

  68
  
        var camera_x = {camera_x};





  
  

  69
  
        var camera_y = {camera_y};





  
  

  70
  
        var camera_z = {camera_z};





  
  

  71
  
        





  
  

  72
  
        var look_x = {look_x};





  
  

  73
  
        var look_y = {look_y};





  
  

  74
  
        var look_z = {look_z};





  
  

  75
  





  
  

  76
  
        var positions = new Float32Array({positions});





  
  

  77
  





  
  

  78
  
        var colors = new Float32Array({colors});





  
  

  79
  





  
  

  80
  
        var points_size = {points_size};





  
  

  81
  





  
  

  82
  
        var axis_size = {axis_size};





  
  

  83
  





  
  

  84
  
        container = document.getElementById( 'container' );





  
  

  85
  





  
  

  86
  
        scene = new THREE.Scene();





  
  

  87
  





  
  

  88
  
        camera = new THREE.PerspectiveCamera( 90, window.innerWidth / window.innerHeight, 0.1, 1000 );





  
  

  89
  
        camera.position.x = camera_x;





  
  

  90
  
        camera.position.y = camera_y;





  
  

  91
  
        camera.position.z = camera_z;





  
  

  92
  
        camera.up = new THREE.Vector3( 0, 0, 1 );       





  
  

  93
  





  
  

  94
  
        if (axis_size > 0){{





  
  

  95
  
            var axisHelper = new THREE.AxisHelper( axis_size );





  
  

  96
  
            scene.add( axisHelper );





  
  

  97
  
        }}





  
  

  98
  





  
  

  99
  
        var geometry = new THREE.BufferGeometry();





  
  

  100
  
        geometry.addAttribute( 'position', new THREE.BufferAttribute( positions, 3 ) );





  
  

  101
  
        geometry.addAttribute( 'color', new THREE.BufferAttribute( colors, 3 ) );





  
  

  102
  
        geometry.computeBoundingSphere();





  
  

  103
  





  
  

  104
  
        var material = new THREE.PointsMaterial( {{ size: points_size, vertexColors: THREE.VertexColors }} );





  
  

  105
  





  
  

  106
  
        points = new THREE.Points( geometry, material );





  
  

  107
  
        scene.add( points );





  
  

  108
  





  
  

  109
  





  
  

  110
  
        renderer = new THREE.WebGLRenderer( {{ antialias: false }} );





  
  

  111
  
        renderer.setPixelRatio( window.devicePixelRatio );





  
  

  112
  
        renderer.setSize( window.innerWidth, window.innerHeight );





  
  

  113
  





  
  

  114
  
        controls = new THREE.OrbitControls( camera, renderer.domElement );





  
  

  115
  
        controls.target.copy( new THREE.Vector3(look_x, look_y, look_z) );





  
  

  116
  
        camera.lookAt( new THREE.Vector3(look_x, look_y, look_z));





  
  

  117
  





  
  

  118
  
        container.appendChild( renderer.domElement );





  
  

  119
  





  
  

  120
  
        window.addEventListener( 'resize', onWindowResize, false );





  
  

  121
  
    }}





  
  

  122
  





  
  

  123
  
    function onWindowResize() {{





  
  

  124
  
        camera.aspect = window.innerWidth / window.innerHeight;





  
  

  125
  
        camera.updateProjectionMatrix();





  
  

  126
  
        renderer.setSize( window.innerWidth, window.innerHeight );





  
  

  127
  
    }}





  
  

  128
  





  
  

  129
  
    function animate() {{





  
  

  130
  
        requestAnimationFrame( animate );





  
  

  131
  
        render();





  
  

  132
  
    }}





  
  

  133
  





  
  

  134
  
    function render() {{





  
  

  135
  
        renderer.render( scene, camera );





  
  

  136
  
    }}





  
  

  137
  
</script>





  
  

  138
  





  
  

  139
  
</body>





  
  

  140
  
</html>





  
  

  141
  
"""





  
  

  142
  





  
  

  143
  
def plot_points(xyz, colors=None, size=0.1, axis=False):





  
  

  144
  





  
  

  145
  
    positions = xyz.reshape(-1).tolist()





  
  

  146
  





  
  

  147
  
    camera_position = xyz.max(0) + abs(xyz.max(0))





  
  

  148
  





  
  

  149
  
    look = xyz.mean(0)





  
  

  150
  





  
  

  151
  
    if colors is None:





  
  

  152
  
        colors = [1,0.5,0] * len(positions)





  
  

  153
  





  
  

  154
  
    elif len(colors.shape) > 1:





  
  

  155
  
        colors = colors.reshape(-1).tolist()





  
  

  156
  





  
  

  157
  
    if axis:





  
  

  158
  
        axis_size = xyz.ptp() * 1.5





  
  

  159
  
    else:





  
  

  160
  
        axis_size = 0





  
  

  161
  





  
  

  162
  
    with open("plot_points.html", "w") as html:





  
  

  163
  
        html.write(TEMPLATE_POINTS.format(





  
  

  164
  
            camera_x=camera_position[0],





  
  

  165
  
            camera_y=camera_position[1],





  
  

  166
  
            camera_z=camera_position[2],





  
  

  167
  
            look_x=look[0],





  
  

  168
  
            look_y=look[1],





  
  

  169
  
            look_z=look[2],





  
  

  170
  
            positions=positions,





  
  

  171
  
            colors=colors,





  
  

  172
  
            points_size=size,





  
  

  173
  
            axis_size=axis_size))





  
  

  174
  





  
  

  175
  
    return IFrame("plot_points.html",width=800, height=800)





  
  

  176
  





  
  

  177
  





  
  

  178
  
TEMPLATE_VG = """





  
  

  179
  
<!DOCTYPE html>





  
  

  180
  
<head>





  
  

  181
  





  
  

  182
  
<title>PyntCloud</title>





  
  

  183
  
<meta charset="utf-8">





  
  

  184
  
<meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">





  
  

  185
  
<style>





  
  

  186
  
    body {{





  
  

  187
  
        color: #cccccc;font-family: Monospace;





  
  

  188
  
        font-size: 13px;





  
  

  189
  
        text-align: center;





  
  

  190
  
        background-color: #050505;





  
  

  191
  
        margin: 0px;





  
  

  192
  
        overflow: hidden;





  
  

  193
  
    }}





  
  

  194
  
    #logo_container {{





  
  

  195
  
        position: absolute;





  
  

  196
  
        top: 0px;





  
  

  197
  
        width: 100%;





  
  

  198
  
    }}





  
  

  199
  
    .logo {{





  
  

  200
  
        max-width: 20%;





  
  

  201
  
    }}





  
  

  202
  
</style>





  
  

  203
  





  
  

  204
  
</head>





  
  

  205
  
<body>





  
  

  206
  





  
  

  207
  
<div>





  
  

  208
  
    <img class="logo" src="https://media.githubusercontent.com/media/daavoo/pyntcloud/master/docs/data/pyntcloud.png">





  
  

  209
  
</div>





  
  

  210
  





  
  

  211
  
<div id="container">





  
  

  212
  
</div>





  
  

  213
  





  
  

  214
  
<script src="http://threejs.org/build/three.js"></script>





  
  

  215
  
<script src="http://threejs.org/examples/js/Detector.js"></script>





  
  

  216
  
<script src="http://threejs.org/examples/js/controls/OrbitControls.js"></script>





  
  

  217
  
<script src="http://threejs.org/examples/js/libs/stats.min.js"></script>





  
  

  218
  





  
  

  219
  
<script>





  
  

  220
  





  
  

  221
  
    if ( ! Detector.webgl ) Detector.addGetWebGLMessage();





  
  

  222
  





  
  

  223
  
    var container, stats;





  
  

  224
  
    var camera, scene, renderer;





  
  

  225
  
    var points;





  
  

  226
  





  
  

  227
  
    init();





  
  

  228
  
    animate();





  
  

  229
  





  
  

  230
  
    function init() {{





  
  

  231
  





  
  

  232
  
        var camera_x = {camera_x};





  
  

  233
  
        var camera_y = {camera_y};





  
  

  234
  
        var camera_z = {camera_z};





  
  

  235
  





  
  

  236
  
        var look_x = {look_x};





  
  

  237
  
        var look_y = {look_y};





  
  

  238
  
        var look_z = {look_z};





  
  

  239
  





  
  

  240
  
        var X = new Float32Array({X});





  
  

  241
  
        var Y = new Float32Array({Y});





  
  

  242
  
        var Z = new Float32Array({Z});





  
  

  243
  





  
  

  244
  
        var R = new Float32Array({R});





  
  

  245
  
        var G = new Float32Array({G});





  
  

  246
  
        var B = new Float32Array({B});





  
  

  247
  





  
  

  248
  
        var S_x = {S_x};





  
  

  249
  
        var S_y = {S_y};





  
  

  250
  
        var S_z = {S_z};





  
  

  251
  





  
  

  252
  
        var n_voxels = {n_voxels};





  
  

  253
  
        var axis_size = {axis_size};





  
  

  254
  





  
  

  255
  
        container = document.getElementById( 'container' );





  
  

  256
  





  
  

  257
  
        scene = new THREE.Scene();





  
  

  258
  





  
  

  259
  
        camera = new THREE.PerspectiveCamera( 90, window.innerWidth / window.innerHeight, 0.1, 1000 );





  
  

  260
  
        camera.position.x = camera_x;





  
  

  261
  
        camera.position.y = camera_y;





  
  

  262
  
        camera.position.z = camera_z;





  
  

  263
  
        camera.up = new THREE.Vector3( 0, 0, 1 );   





  
  

  264
  





  
  

  265
  
        if (axis_size > 0){{





  
  

  266
  
            var axisHelper = new THREE.AxisHelper( axis_size );





  
  

  267
  
            scene.add( axisHelper );





  
  

  268
  
        }}





  
  

  269
  





  
  

  270
  
        var geometry = new THREE.BoxGeometry( S_x, S_z, S_y );





  
  

  271
  





  
  

  272
  
        for ( var i = 0; i < n_voxels; i ++ ) {{            





  
  

  273
  
            var mesh = new THREE.Mesh( geometry, new THREE.MeshBasicMaterial() );





  
  

  274
  
            mesh.material.color.setRGB(R[i], G[i], B[i]);





  
  

  275
  
            mesh.position.x = X[i];





  
  

  276
  
            mesh.position.y = Y[i];





  
  

  277
  
            mesh.position.z = Z[i];





  
  

  278
  
            scene.add(mesh);





  
  

  279
  
        }}





  
  

  280
  
        





  
  

  281
  
        renderer = new THREE.WebGLRenderer( {{ antialias: false }} );





  
  

  282
  
        renderer.setPixelRatio( window.devicePixelRatio );





  
  

  283
  
        renderer.setSize( window.innerWidth, window.innerHeight );





  
  

  284
  





  
  

  285
  
        controls = new THREE.OrbitControls( camera, renderer.domElement );





  
  

  286
  
        controls.target.copy( new THREE.Vector3(look_x, look_y, look_z) );





  
  

  287
  
        camera.lookAt( new THREE.Vector3(look_x, look_y, look_z));





  
  

  288
  





  
  

  289
  
        container.appendChild( renderer.domElement );





  
  

  290
  





  
  

  291
  
        window.addEventListener( 'resize', onWindowResize, false );





  
  

  292
  
    }}





  
  

  293
  





  
  

  294
  
    function onWindowResize() {{





  
  

  295
  
        camera.aspect = window.innerWidth / window.innerHeight;





  
  

  296
  
        camera.updateProjectionMatrix();





  
  

  297
  
        renderer.setSize( window.innerWidth, window.innerHeight );





  
  

  298
  
    }}





  
  

  299
  





  
  

  300
  
    function animate() {{





  
  

  301
  
        requestAnimationFrame( animate );





  
  

  302
  
        render();





  
  

  303
  
    }}





  
  

  304
  





  
  

  305
  
    function render() {{





  
  

  306
  
        renderer.render( scene, camera );





  
  

  307
  
    }}





  
  

  308
  
</script>





  
  

  309
  
</body>





  
  

  310
  
</html>





  
  

  311
  
"""





  
  

  312
  





  
  

  313
  





  
  

  314
  
def plot_voxelgrid(v_grid, cmap="Oranges", axis=False):





  
  

  315
  





  
  

  316
  
    scaled_shape = v_grid.shape / min(v_grid.shape)





  
  

  317
  





  
  

  318
  
    # coordinates returned from argwhere are inversed so use [:, ::-1]





  
  

  319
  
    points = np.argwhere(v_grid.vector)[:, ::-1] * scaled_shape





  
  

  320
  





  
  

  321
  
    s_m = plt.cm.ScalarMappable(cmap=cmap)





  
  

  322
  
    rgb = s_m.to_rgba(v_grid.vector.reshape(-1)[v_grid.vector.reshape(-1) > 0])[:,:-1]





  
  

  323
  





  
  

  324
  
    camera_position = points.max(0) + abs(points.max(0))





  
  

  325
  
    look = points.mean(0)





  
  

  326
  
    





  
  

  327
  
    if axis:





  
  

  328
  
        axis_size = points.ptp() * 1.5





  
  

  329
  
    else:





  
  

  330
  
        axis_size = 0





  
  

  331
  





  
  

  332
  
    with open("plotVG.html", "w") as html:





  
  

  333
  
        html.write(TEMPLATE_VG.format( 





  
  

  334
  
            camera_x=camera_position[0],





  
  

  335
  
            camera_y=camera_position[1],





  
  

  336
  
            camera_z=camera_position[2],





  
  

  337
  
            look_x=look[0],





  
  

  338
  
            look_y=look[1],





  
  

  339
  
            look_z=look[2],





  
  

  340
  
            X=points[:,0].tolist(),





  
  

  341
  
            Y=points[:,1].tolist(),





  
  

  342
  
            Z=points[:,2].tolist(),





  
  

  343
  
            R=rgb[:,0].tolist(),





  
  

  344
  
            G=rgb[:,1].tolist(),





  
  

  345
  
            B=rgb[:,2].tolist(),





  
  

  346
  
            S_x=scaled_shape[0],





  
  

  347
  
            S_y=scaled_shape[2],





  
  

  348
  
            S_z=scaled_shape[1],





  
  

  349
  
            n_voxels=sum(v_grid.vector.reshape(-1) > 0),





  
  

  350
  
            axis_size=axis_size))





  
  

  351
  





  
  

  352
  
    return IFrame("plotVG.html",width=800, height=800)