volume-visualization/volumes/views.py

from django.core.urlresolvers import reverse
from django.shortcuts import render, render_to_response
from django.template import RequestContext
from django.http import HttpResponseRedirect, HttpResponse
from django.contrib import messages

from django.conf import settings

import json

from mongoengine import ValidationError

from multiprocessing import Process

from .models import Volume
from .forms import VolumeForm

from volumes.processing.service import SliceGenerator, SubvolumeCreator

import logging

import os

logger = logging.getLogger(__name__)

# volumes views


def index(request):
    return render(request, 'volumes/index.html', {'volumes': Volume.objects()})


def show(request, id):
    try:
        volume = Volume.objects(id=id)[0]
    except (IndexError, ValidationError) as e:
        return handleException(request, id, e)

    return render(request, 'volumes/show.html', {'volume': volume})


def showStatus(request, id):
    try:
        volume = Volume.objects(id=id)[0]
    except (IndexError, ValidationError) as e:
        return handleException(request, id, e)

    jsonDump = json.dumps({
        'volumeId': str(volume.id),
        'generateSlicesStatus': volume.generateSlicesStatus
    })
    return HttpResponse(jsonDump, content_type="json")


def add(request):
    logger.debug('processing add requested')
    if request.method == 'GET':
        return edit(request, None)
    elif request.method == 'POST':
        form = VolumeForm(request.POST)

        if form.is_valid():
            volume = form.save()
            return HttpResponseRedirect(reverse('volumes:show', args=(volume.id,)))
        else:
            messages.error(request, 'input not valid')
            return HttpResponseRedirect(reverse('volumes:home'))


def edit(request, id=None):
    if id is not None:
        try:
            volume = Volume.objects(id=id)[0]
        except (IndexError, ValidationError) as e:
            return handleException(request, id, e)

        if request.method == 'POST':
            form = VolumeForm(request.POST, instance=volume)
            if form.is_valid():
                instance = form.save()
                return HttpResponseRedirect(reverse('volumes:show', args=(instance.id,)))
        else:
            form = VolumeForm(instance=volume)
            submitAction = reverse('volumes:edit', args=(id,))
    else:
        form = VolumeForm()
        submitAction = reverse('volumes:add')

    template_context = {
        'form': form,
        'submitAction': submitAction,
        'defaultPath': settings.DEFAULT_IMPORT_PATH,
        # 'fileList': json.dumps(__gatherInputFolderList())'''
        'fileList': json.dumps([])
    }
    return render_to_response('volumes/edit.html', template_context, RequestContext(request))


def addList(request):
    if request.method == 'POST':
        data = request.POST
        imageSequences = 'imagesequences' in data
        paths = data['paths'].split('\r\n')

        volumesToProcess = []

        for path in paths:
            pathParts = path.split(':')

            volume = Volume()
            volume.name = pathParts[0].strip()
            volume.path = pathParts[1].strip()
            volume.imageSequence = imageSequences
            volume = volume.save()
            volumesToProcess.append(volume.id)

        process = Process(target=SliceGenerator.generateListOfVolumes, args=(volumesToProcess,))
        process.start()

        messages.info(request, 'automatic processing started')
        return HttpResponseRedirect(reverse('volumes:home'))

    ''' this is a simple view, that adds volumes from a list, and preprocesses them '''
    template_context = {
        'submitAction': reverse('volumes:addList')
    }

    return render_to_response('volumes/addList.html', template_context, RequestContext(request))


def delete(request, id):
    try:
        volume = Volume.objects(id=id)[0]
    except (IndexError, ValidationError) as e:
        return handleException(request, id, e)

    volume.delete()
    return HttpResponseRedirect(reverse('volumes:home'))


def handleException(request, id, e):
    if type(e) is ValidationError:
        messages.error(request, '%s not a valid ObjectId' % id)
    elif type(e) is IndexError:
        messages.error(request, 'object for %s not found in db' % id)

    return HttpResponseRedirect(reverse('volumes:home'))


def showSprite(request, id, spriteId):
    try:
        sprite, contenttype = Volume.read_sprite(id, spriteId)
    except (IndexError, ValidationError) as e:
        return handleException(request, spriteId, e)

    # need a fallback for old data
    # can be removed in production, only needed for early test datas
    if contenttype is None:
        contenttype = 'image/jpeg'

    response = HttpResponse(sprite.read(), content_type=contenttype)
    response['Content-Length'] = sprite.length

    return response


def getTextureInfo(request, id, size):
    if size == '':
        size = None

    try:
        texture = Volume.read_texture(id, size)
    except (IndexError, ValidationError) as e:
        return handleException(request, id, e)

    request.session['requestedRes'] = size

    jsonDump = texture.to_json()
    return HttpResponse(jsonDump, content_type="json")


def deleteTexture(request, id, size):
    try:
        size = int(size)
    except ValueError:
        messages.error(request, 'please provide a valid value(s) for "size"')
        return HttpResponseRedirect(reverse('volumes:show', args=(id,)))

    try:
        Volume.objects(id=id).first().remove_texture(size)
    except (IndexError, ValidationError) as e:
        return handleException(request, id, e)

    return HttpResponseRedirect(reverse('volumes:show', args=(id,)))


def render3D(request, id, res=None):
    try:
        volume = Volume.objects(id=id)[0]
    except (IndexError, ValidationError) as e:
        return handleException(request, id, e)

    if volume.textures is None or len(volume.textures) == 0:
        messages.error(request, 'please run the generation')
        return HttpResponseRedirect(reverse('volumes:show', args=(volume.id,)))

    if res is not None:
        res = int(res)

    #SubvolumeCreator.preread_volume(id)

    requestedResFound = False
    sizes = []
    for index in range(0, len(volume.textures)):
        curSize = volume.textures[index].size
        sizes.append(curSize)
        if curSize == res:
            requestedResFound = True

    sizes.sort()

    defaultSize = sizes[0]

    if requestedResFound:
        defaultSize = res

    return render(request, 'volumes/render.html', {
            'volume': volume,
            'textureSizes': sizes,
            'defaultSize': defaultSize
        })


def __gatherInputFolderList():
    fileList = __controlForSubfolder(settings.DEFAULT_IMPORT_PATH, 0)
    return fileList


def __controlForSubfolder(path, depth):
    outputList = [path]

    try:
        dirContent = os.listdir(path)
    except OSError as e:
        logger.error('failed to read directory %s with error %s' % (path, str(e)))
        return []

    for fileItem in dirContent:
        fileItem = os.path.join(path, fileItem)
        if os.path.isdir(fileItem) is True:
            dirList = __controlForSubfolder(fileItem, depth + 1)
            outputList += dirList
        else:
            outputList.append(fileItem)

    return outputList