source: inundation/ga/storm_surge/pyvolution/realtime_visualisation_new.py @ 1278

from visual import *

class Surface:
    def __init__(self,domain,scale_z=1.0):
        """Create visualisation of domain
        """

        self.frame  = frame()
        autoscale=0
        self.bed_model   = faces(frame=self.frame)
        self.stage_model = faces(frame=self.frame)
        self.domain = domain
        self.scale_z  = scale_z

        self.vertices = domain.vertex_coordinates
        self.bed   = domain.quantities['elevation'].vertex_values
        self.stage = domain.quantities['stage'].vertex_values
        self.xmomentum = domain.quantities['xmomentum'].vertex_values
        self.ymomentum = domain.quantities['ymomentum'].vertex_values

        self.max_x = max(max(self.vertices[:,0],self.vertices[:,2],self.vertices[:,4]))
        self.min_x = min(min(self.vertices[:,0],self.vertices[:,2],self.vertices[:,4]))
        self.max_y = max(max(self.vertices[:,1],self.vertices[:,3],self.vertices[:,5]))
        self.min_y = min(min(self.vertices[:,1],self.vertices[:,3],self.vertices[:,5]))
        self.range_x = self.max_x - self.min_x
        self.range_y = self.max_y - self.min_y

        self.range_xy = max(self.range_x, self.range_y)

        self.max_bed = max(max(self.bed))
        self.min_bed = min(min(self.bed))
        self.range_bed = max(self.max_bed - self.min_bed, 1e-10)*2.0

        print 'min_bed=',self.min_bed
        print 'max_bed=',self.max_bed
        print 'range_bed=',self.range_bed

        #print self.max_x, self.min_x, self.max_y, self.min_y,
        #self.min_bed print self.max_bed, self.range_x, self.range_y,
        #self.range_xy, self.range_bed
        #print 'Calculating triangles'

        self.pos     = zeros( (6*len(domain),3), Float)
        self.colour  = zeros( (6*len(domain),3), Float)
        self.normals = zeros( (6*len(domain),3), Float)

        #print 'keys',self.domain.quantities.keys()
        #print 'shape of stage',shape(self.stage)

        self.border_model = curve(frame = self.frame, pos=[(0,0),(0,1),(1,1),(1,0),(0,0)])
        self.timer=label(pos=(0.75,0.5,0.5),text='Time=%10.5e'%self.domain.time)

        #self.update_all()

    def update_all(self):

        self.update_bed()
        self.update_stage()

    def update_timer(self):
        self.timer.text='Time=%10.5e'%self.domain.time

    def update_bed(self):

        #print 'update bed arrays'
        c0 = 0.3
        c1 = 0.3
        c2 = 0.3
        self.update_arrays(self.bed,  (c0,c1,c2) )

        #print 'update bed image'
        self.bed_model.pos    = self.pos
        self.bed_model.color  = self.colour
        self.bed_model.normal = self.normals


    def update_stage(self):
        c0 = 0.1
        c1 = 0.4
        c2 = 0.99
        #print 'update stage arrays'
        self.update_arrays(self.stage, (c0,c1,c2) )
        #print 'update stage image'
        self.stage_model.pos    = self.pos
        self.stage_model.color  = self.colour
        self.stage_model.normal = self.normals

    def update_xmomentum(self):
        c0 = 0.1
        c1 = 0.4
        c2 = 0.99
        #print 'update stage arrays'
        self.update_arrays(self.xmomentum, (c0,c1,c2) )
        #print 'update stage image'
        self.stage_model.pos    = self.pos
        self.stage_model.color  = self.colour
        self.stage_model.normal = self.normals

    def update_ymomentum(self):
        c0 = 0.1
        c1 = 0.4
        c2 = 0.99
        #print 'update stage arrays'
        self.update_arrays(self.ymomentum, (c0,c1,c2) )
        #print 'update stage image'
        self.stage_model.pos    = self.pos
        self.stage_model.color  = self.colour
        self.stage_model.normal = self.normals

    def update_arrays(self,quantity,qcolor):

        col = asarray(qcolor)

        N = len(self.domain)

        scale_z = self.scale_z
        min_x = self.min_x
        min_y = self.min_y
        range_xy = self.range_xy
        range_bed = self.range_bed

        vertices = self.vertices
        pos      = self.pos
        normals  = self.normals
        colour   = self.colour

        try:
            update_arrays_weave(vertices,quantity,col,pos,normals,colour,N,
                                min_x,min_y,range_xy,range_bed,scale_z)
        except:
            update_arrays_python(vertices,quantity,col,pos,normals,colour,N,
                                 min_x,min_y,range_xy,range_bed,scale_z)



def  update_arrays_python(vertices,quantity,col,pos,normals,colour,N,
                          min_x,min_y,range_xy,range_bed,scale_z):

    from math import sqrt
    normal = zeros( 3, Float)
    v = zeros( (3,3), Float)
    s = 1.0

    for i in range( N ):

        for j in range(3):
            v[j,0] = (vertices[i,2*j  ]-min_x)/range_xy
            v[j,1] = (vertices[i,2*j+1]-min_y)/range_xy
            v[j,2] = quantity[i,j]/range_bed*scale_z

        v10 = v[1,:]-v[0,:]
        v20 = v[2,:]-v[0,:]

        normal[0] = v10[1]*v20[2] - v20[1]*v10[2]
        normal[1] = v10[2]*v20[0] - v20[2]*v10[0]
        normal[2] = v10[0]*v20[1] - v20[0]*v10[1]

        norm = sqrt( normal[0]**2 + normal[1]**2 + normal[2]**2)

        normal[0] = normal[0]/norm
        normal[1] = normal[1]/norm
        normal[2] = normal[2]/norm

        pos[6*i  ,:] = v[0,:]
        pos[6*i+1,:] = v[1,:]
        pos[6*i+2,:] = v[2,:]
        pos[6*i+3,:] = v[0,:]
        pos[6*i+4,:] = v[2,:]
        pos[6*i+5,:] = v[1,:]



        colour[6*i  ,:] = s*col
        colour[6*i+1,:] = s*col
        colour[6*i+2,:] = s*col
        colour[6*i+3,:] = s*col
        colour[6*i+4,:] = s*col
        colour[6*i+5,:] = s*col

        s =  15.0/8.0 - s

        normals[6*i  ,:] = normal
        normals[6*i+1,:] = normal
        normals[6*i+2,:] = normal
        normals[6*i+3,:] = -normal
        normals[6*i+4,:] = -normal
        normals[6*i+5,:] = -normal



def  update_arrays_weave(vertices,quantity,col,pos,normals,colour,
                         N,min_x,min_y,range_xy,range_bed,scale_z):

    import weave
    from weave import converters

    from math import sqrt
    normal = zeros( 3, Float)
    v = zeros( (3,3), Float)
    v10 = zeros( 3, Float)
    v20 = zeros( 3, Float)

    code1 = """
        double s = 1.0;

        for (int i=0; i<N ; i++ ) {
            for (int j=0; j<3 ; j++) {
                v(j,0) = (vertices(i,2*j  )-min_x)/range_xy;
                v(j,1) = (vertices(i,2*j+1)-min_y)/range_xy;
                v(j,2) = quantity(i,j)/range_bed*scale_z;
            }


            for (int j=0; j<3; j++) {
                v10(j) = v(1,j)-v(0,j);
                v20(j) = v(2,j)-v(0,j);
            }

            normal(0) = v10(1)*v20(2) - v20(1)*v10(2);
            normal(1) = v10(2)*v20(0) - v20(2)*v10(0);
            normal(2) = v10(0)*v20(1) - v20(0)*v10(1);

            double norm =  sqrt(normal(0)*normal(0) + normal(1)*normal(1) + normal(2)*normal(2));

            normal(0) = normal(0)/norm;
            normal(1) = normal(1)/norm;
            normal(2) = normal(2)/norm;

            for (int j=0; j<3; j++) {
                pos(6*i  ,j) = v(0,j);
                pos(6*i+1,j) = v(1,j);
                pos(6*i+2,j) = v(2,j);
                pos(6*i+3,j) = v(0,j);
                pos(6*i+4,j) = v(2,j);
                pos(6*i+5,j) = v(1,j);

                colour(6*i  ,j) = s*col(j);
                colour(6*i+1,j) = s*col(j);
                colour(6*i+2,j) = s*col(j);
                colour(6*i+3,j) = s*col(j);
                colour(6*i+4,j) = s*col(j);
                colour(6*i+5,j) = s*col(j);

                normals(6*i  ,j) = normal(j);
                normals(6*i+1,j) = normal(j);
                normals(6*i+2,j) = normal(j);
                normals(6*i+3,j) = -normal(j);
                normals(6*i+4,j) = -normal(j);
                normals(6*i+5,j) = -normal(j);
                }

            s =  15.0/8.0 - s;
        }

        """

    weave.inline(code1, ['vertices','quantity','col','pos','normals','colour','N',
                         'min_x','min_y','range_xy','range_bed','scale_z','v','normal','v10','v20'],
                 type_converters = converters.blitz, compiler='gcc');


scene.width = 1000
scene.height = 800

#Original
scene.center = (0.5,0.5,0)
scene.forward = vector(-0.1, 0.5, -0.5)

#Temporary (for bedslope)
#scene.forward = vector(0.0006, 0.7, -0.03)


#Temporary for hackett - begin
#scene.autoscale = 0
#scene.scale = (0.002, 0.002, 0.01) #Scale z so that countours stand out more
#scene.center = (300.0,500.0,-10)
#Temporary for hackett - end


scene.ambient = 0.4
#scene.lights = [(0.6, 0.3, 0.2), (0.1, -0.5, 0.4), (-0.1, 0.1, -0.4),
#               (-0.2, 0.2, 0.1)]

scene.lights = [(0.6, 0.3, 0.2), (0.1, -0.5, 0.4)]



def create_surface(domain):

    surface = Surface(domain)
    domain.surface = surface

    surface.update_bed()
    surface.update_stage()
    #surface.update_xmomentum()
    #surface.update_ymomentum
    surface.update_timer()

def update(domain):

    #print 'start visual update'
    surface = domain.surface
    surface.update_stage()
    #surface.update_xmomentum()
    #surface.update_ymomentum()
    surface.update_timer()
    #print 'end visual update'