volume-visualization/volumes/processing/service/SubvolumeCreator.py

from django.conf import settings
from django.core.cache import cache

import io
import logging

import math
import numpy as np
import os
from PIL import Image
from skimage import img_as_ubyte
import time
from threading import Thread

from multiprocessing import Process

from volumes.models import Volume
import loadtests.facade as loadtests

logger = logging.getLogger(__name__)


class SubvolumeCreator(Thread):
    ''' this implementation is only needed for testing'''
    def __init__(self, volumeId, x, y, z, t, minWidth, sqrtZ, numberOfLayers, spriteId, requestedRes, starttime, testId):
        Thread.__init__(self)

        self.volumeId = volumeId
        self.x = x
        self.y = y
        self.z = z
        self.t = t
        self.minWidth = minWidth
        self.sqrtZ = sqrtZ
        self.numberOfLayers = numberOfLayers
        self.spriteId = spriteId
        self.requestedRes = requestedRes
        self.starttime = starttime
        self.testId = testId

    def run(self):
        subvolumeCreator(self.volumeId,
                         self.x,
                         self.y,
                         self.z,
                         self.t,
                         self.minWidth,
                         self.sqrtZ,
                         self.numberOfLayers,
                         self.spriteId,
                         self.requestedRes,
                         self.starttime,
                         self.testId)


def subvolumeCreator(volumeId, x, y, z, t, minWidth, sqrtZ, numberOfLayers, spriteId, spriteformat, requestedRes, starttime, testId):
    ''' this method is either called in view or SubvolumeCreator.SubvolumeCreator thread '''

    volume = Volume.objects(id=volumeId).first()
    requestedRes = int(requestedRes)
    requestedShape = (requestedRes, requestedRes)
    logger.debug('running')
    if settings.SUBVOLUME_STATIC:
        logger.debug('debugging context, generate read image')
        subvolume = np.zeros((minWidth * sqrtZ, minWidth * sqrtZ), dtype=np.uint8)
        subvolume[:, :] = 200
        image = Image.fromarray(subvolume)
        image = image.resize(requestedShape)
        format = "jpeg"
        buff = io.BytesIO()
        image.save(buff, format=format, progressive=True, quality=95)
        buff.seek(0, 0)
        cache.set(get_sprite_filename(spriteId, spriteformat), buff, settings.SUBVOLUME_CACHING_TIME)
        '''gridfshelper.savefile(get_sprite_filename(spriteId, spriteformat), buff)'''
        return

    imageAsArray = volume.get_frame_numpy_array(t)
    logger.debug('generating subvolume width shape (%d, %d, %d)' % (numberOfLayers, minWidth, minWidth))
    logger.debug('timeframe (%d)' % t)
    logger.debug('roi (%d, %d, %d)' % (x, y, z))

    subvolume = np.empty((minWidth * sqrtZ, minWidth * sqrtZ), dtype=imageAsArray.dtype)
    logger.debug('resulting sprite shape: %d, %d' % subvolume.shape)
    logger.debug('minWidth: %d' % minWidth)
    logger.debug('layers per row: %d' % sqrtZ)
    layerCounter = 0
    copy_start_time = time.time()
    for index in range(z, z + numberOfLayers):
        zlayer = imageAsArray[index]

        yoffset = math.floor(layerCounter / sqrtZ) * minWidth
        xoffset = (layerCounter % sqrtZ) * minWidth

        subvolume[yoffset: yoffset+minWidth, xoffset: xoffset+minWidth] = zlayer[y: y+minWidth, x: x+minWidth]

        layerCounter += 1

    copy_end_time = time.time()

    subvolume = img_as_ubyte(subvolume)
    image = Image.fromarray(subvolume)
    image = image.resize(requestedShape, resample=Image.BILINEAR)
    format = spriteformat
    buff = io.BytesIO()
    image.save(buff, format=format, progressive=True, quality=95)
    buff.seek(0, 0)
    spriteFilename = get_sprite_filename(spriteId, spriteformat)

    bufferValue = buff.getvalue()
    logger.debug('requestedRes: %d' % requestedRes)

    if testId is None:
        cache.set(spriteFilename, bufferValue, settings.SUBVOLUME_CACHING_TIME)

    processing_endtime = time.time()
    copy_duration = copy_end_time - copy_start_time
    processing_duration = processing_endtime - starttime

    if testId is not None:
        loadtests.addTestResult(
            testId,
            imageAsArray.shape,
            (numberOfLayers, minWidth, minWidth),
            (x, y, z),
            processing_duration,
            copy_duration,
            imageAsArray.dtype
        )
    else:
        logger.debug('no testid given')

    logger.debug(str(os.getpid()) + 'finished, duration: %s of ' % (str(processing_duration)))


def get_sprite_filename(sprite_id, sprite_format):
    return '%s.%s' % (str(sprite_id), sprite_format)

def preread_volume(volume_id):
    logger.debug('preread called')
    process = Process(target=_preread_volume, args=(volume_id,))
    process.start()

def _preread_volume(volume_id):
    logger.debug('_prearead called');
    volume = Volume.objects(id=volume_id).first()

    raw_frames = volume.rawFrames
    for framenumber in range(0, len(raw_frames)):

        logger.debug('read frame array with framenumber %d' % framenumber)
        raw = volume.get_frame_numpy_array(framenumber)
        logger.debug(raw.shape)
        tmpdata = np.empty((raw.shape[1], raw.shape[2]),dtype=raw.dtype)
        for slice in raw:
            tmpdata[:, :] = slice[:, :]

    logger.debug('end _preread')