예제 #1
0
    def _getTile(self, item, z, x, y, imageArgs):
        """
        Get an large image tile.

        :param item: the item to get a tile from.
        :param z: tile layer number (0 is the most zoomed-out).
        .param x: the X coordinate of the tile (0 is the left side).
        .param y: the Y coordinate of the tile (0 is the top).
        :param imageArgs: additional arguments to use when fetching image data.
        :return: a function that returns the raw image data.
        """
        try:
            x, y, z = int(x), int(y), int(z)
        except ValueError:
            raise RestException('x, y, and z must be integers', code=400)
        if x < 0 or y < 0 or z < 0:
            raise RestException('x, y, and z must be positive integers',
                                code=400)
        try:
            tileData, tileMime = self.imageItemModel.getTile(
                item, x, y, z, **imageArgs)
        except TileGeneralException as e:
            raise RestException(e.message, code=404)
        setResponseHeader('Content-Type', tileMime)
        setRawResponse()
        return tileData
예제 #2
0
    def thumbnail(self, segmentation, params):
        contentDisp = params.get('contentDisposition', None)
        if contentDisp is not None and contentDisp not in {'inline', 'attachment'}:
            raise ValidationException('Unallowed contentDisposition type "%s".' % contentDisp,
                                      'contentDisposition')

        # TODO: convert this to make Segmentation use an AccessControlMixin
        image = Image().load(
            segmentation['imageId'], level=AccessType.READ, user=self.getCurrentUser(), exc=True)

        width = int(params.get('width', 256))

        thumbnailImageStream = Segmentation().boundaryThumbnail(segmentation, image, width)
        if thumbnailImageStream is None:
            raise RestException('This segmentation is failed, and thus has no thumbnail.', code=410)
        thumbnailImageData = thumbnailImageStream.getvalue()

        # Only setRawResponse now, as this handler may return a JSON error
        # earlier
        setRawResponse()
        setResponseHeader('Content-Type', 'image/jpeg')
        contentName = '%s_segmentation_thumbnail.jpg' % image['name']
        if contentDisp == 'inline':
            setResponseHeader('Content-Disposition', 'inline; filename="%s"' % contentName)
        else:
            setResponseHeader('Content-Disposition', 'attachment; filename="%s"' % contentName)
        setResponseHeader('Content-Length', len(thumbnailImageData))

        return thumbnailImageData
예제 #3
0
    def getAnnotationMarkupMask(self, annotation, featureId, params):
        self._ensureMarkup(annotation, featureId)

        markupFile = Annotation().getMarkupFile(annotation, featureId)

        if markupFile:
            return File().download(markupFile, headers=True, contentDisposition='inline')
        else:
            image = Image().load(annotation['imageId'], force=True, exc=True)
            markupMask = numpy.zeros(
                (
                    image['meta']['acquisition']['pixelsY'],
                    image['meta']['acquisition']['pixelsX']
                ),
                dtype=numpy.uint8
            )
            markupMaskEncodedStream = ScikitSegmentationHelper.writeImage(markupMask, 'png')
            markupMaskEncodedData = markupMaskEncodedStream.getvalue()

            setRawResponse()
            setResponseHeader('Content-Type', 'image/png')
            contentName = 'annotation_%s_%s.png' % (
                annotation['_id'],
                # Rename features to ensure the file is downloadable on Windows
                featureId.replace(' : ', ' ; ').replace('/', ',')
            )
            setResponseHeader('Content-Disposition', 'inline; filename="%s"' % contentName)
            setResponseHeader('Content-Length', len(markupMaskEncodedData))

            return markupMaskEncodedData
예제 #4
0
    def getAnnotationMarkupRendered(self, annotation, featureId, params):
        contentDisp = params.get('contentDisposition', None)
        if contentDisp is not None and contentDisp not in {'inline', 'attachment'}:
            raise ValidationException('Unallowed contentDisposition type "%s".' % contentDisp,
                                      'contentDisposition')

        self._ensureMarkup(annotation, featureId)

        renderData = Annotation().renderMarkup(annotation, featureId)

        renderEncodedStream = ScikitSegmentationHelper.writeImage(renderData, 'jpeg')
        renderEncodedData = renderEncodedStream.getvalue()

        # Only setRawResponse now, as this handler may return a JSON error earlier
        setRawResponse()
        setResponseHeader('Content-Type', 'image/jpeg')
        contentName = 'annotation_%s_%s.jpg' % (
            annotation['_id'],
            # Rename features to ensure the file is downloadable on Windows
            featureId.replace(' : ', ' ; ').replace('/', ',')
        )
        if contentDisp == 'inline':
            setResponseHeader(
                'Content-Disposition',
                'inline; filename="%s"' % contentName)
        else:
            setResponseHeader(
                'Content-Disposition',
                'attachment; filename="%s"' % contentName)
        setResponseHeader('Content-Length', len(renderEncodedData))

        return renderEncodedData
예제 #5
0
 def getTilesRegion(self, item, params):
     params = self._parseParams(params, True, [
         ('left', float, 'region', 'left'),
         ('top', float, 'region', 'top'),
         ('right', float, 'region', 'right'),
         ('bottom', float, 'region', 'bottom'),
         ('regionWidth', float, 'region', 'width'),
         ('regionHeight', float, 'region', 'height'),
         ('units', str, 'region', 'units'),
         ('width', int, 'output', 'maxWidth'),
         ('height', int, 'output', 'maxHeight'),
         ('magnification', float, 'scale', 'magnification'),
         ('mm_x', float, 'scale', 'mm_x'),
         ('mm_y', float, 'scale', 'mm_y'),
         ('exact', bool, 'scale', 'exact'),
         ('encoding', str),
         ('jpegQuality', int),
         ('jpegSubsampling', int),
     ])
     try:
         regionData, regionMime = self.imageItemModel.getRegion(
             item, **params)
     except TileGeneralException as e:
         raise RestException(e.message)
     except ValueError as e:
         raise RestException('Value Error: %s' % e.message)
     setResponseHeader('Content-Type', regionMime)
     setRawResponse()
     return regionData
예제 #6
0
 def testAnalysisXmlDetection(self, params):
     """Return the nuclei detection XML spec as a test case."""
     xml_file = os.path.abspath(
         os.path.join(os.path.dirname(__file__), '..', 'histomicstk', 'cli',
                      'NucleiDetection', 'NucleiDetection.xml'))
     with open(xml_file) as f:
         xml = f.read()
     setResponseHeader('Content-Type', 'application/xml')
     setRawResponse()
     return xml
예제 #7
0
 def testAnalysisXmlFeatures(self, params):
     """Return the nuclei feature classification XML spec as a test case."""
     xml_file = os.path.abspath(
         os.path.join(os.path.dirname(__file__), '..', 'server',
                      'ComputeNucleiFeatures', 'ComputeNucleiFeatures.xml'))
     with open(xml_file) as f:
         xml = f.read()
     setResponseHeader('Content-Type', 'application/xml')
     setRawResponse()
     return xml
예제 #8
0
    def thumbnail(self, image, params):
        width = int(params.get('width', 256))
        height = int(params.get('height', 256))
        thumbData, thumbMime = ImageItem().getThumbnail(image, width=width, height=height)

        # Only setRawResponse now, as this handler may return a JSON error
        # earlier
        setRawResponse()
        setResponseHeader('Content-Type', thumbMime)
        return thumbData
예제 #9
0
    def thumbnail(self, image, params):
        width = int(params.get('width', 256))
        height = int(params.get('height', 256))
        thumbData, thumbMime = ImageItem().getThumbnail(image, width=width, height=height)

        # Only setRawResponse now, as this handler may return a JSON error
        # earlier
        setRawResponse()
        setResponseHeader('Content-Type', thumbMime)
        return thumbData
예제 #10
0
 def _forward(self):
     """
     Forward a request to the same path with a slash added.
     """
     result = '\n'.join([
         '<html>', '<head><title>301 Moved Permanently</title></head>',
         '<body>', '<center><h1>301 Moved Permanently</h1></center>',
         '</body>', '</html>'])
     setResponseHeader('Location', cherrypy.request.path_info + '/')
     setResponseHeader('Content-Type', 'text/html')
     setRawResponse()
     cherrypy.response.status = 301
     return result.encode('utf8')
예제 #11
0
파일: __init__.py 프로젝트: girder/girder
    def downloadKeyFile(self, file, algo):
        self._validateAlgo(algo)

        if algo not in file:
            raise RestException('This file does not have the %s hash computed.' % algo)
        keyFileBody = '%s\n' % file[algo]
        name = '.'.join((file['name'], algo))

        setResponseHeader('Content-Length', len(keyFileBody))
        setResponseHeader('Content-Type', 'text/plain')
        setContentDisposition(name)
        setRawResponse()

        return keyFileBody
예제 #12
0
    def downloadKeyFile(self, file, algo, params):
        self._validateAlgo(algo)

        if algo not in file:
            raise RestException('This file does not have the %s hash computed.' % algo)
        hash = file[algo]
        name = '.'.join((file['name'], algo))

        setResponseHeader('Content-Length', len(hash))
        setResponseHeader('Content-Type', 'text/plain')
        setResponseHeader('Content-Disposition', 'attachment; filename="%s"' % name)
        setRawResponse()

        return hash
예제 #13
0
파일: __init__.py 프로젝트: wegiangb/girder
    def downloadKeyFile(self, file, algo):
        self._validateAlgo(algo)

        if algo not in file:
            raise RestException('This file does not have the %s hash computed.' % algo)
        keyFileBody = '%s\n' % file[algo]
        name = '.'.join((file['name'], algo))

        setResponseHeader('Content-Length', len(keyFileBody))
        setResponseHeader('Content-Type', 'text/plain')
        setContentDisposition(name)
        setRawResponse()

        return keyFileBody
예제 #14
0
def _getHdf5Dataset(self, item):
    try:
        setResponseHeader('Content-Type', 'image/png')
        setRawResponse()
        hdf5Path = [i for i in item['meta']
                    if 'hdf5Path' in i.keys()][0]['hdf5Path']
        pathInHdf5 = [i for i in item['meta']
                      if 'pathInHdf5' in i.keys()][0]['pathInHdf5']
        figure = render_hdf5_dataset(hdf5Path, pathInHdf5)
        buf = BytesIO()
        figure.savefig(buf, format='png')
        return b64encode(buf.getvalue())
    except:
        pass
예제 #15
0
 def getTile(self, image, z, x, y, params):
     try:
         x, y, z = int(x), int(y), int(z)
     except ValueError:
         raise RestException('x, y, and z must be integers')
     if x < 0 or y < 0 or z < 0:
         raise RestException('x, y, and z must be positive integers')
     try:
         tileData, tileMime = ImageItem().getTile(image, x, y, z)
     except TileGeneralException as e:
         raise RestException(e.message, code=404)
     setResponseHeader('Content-Type', tileMime)
     setRawResponse()
     return tileData
예제 #16
0
 def getTile(self, image, z, x, y, params):
     try:
         x, y, z = int(x), int(y), int(z)
     except ValueError:
         raise RestException('x, y, and z must be integers')
     if x < 0 or y < 0 or z < 0:
         raise RestException('x, y, and z must be positive integers')
     try:
         tileData, tileMime = ImageItem().getTile(image, x, y, z)
     except TileGeneralException as e:
         raise RestException(e.message, code=404)
     setResponseHeader('Content-Type', tileMime)
     setRawResponse()
     return tileData
예제 #17
0
    def downloadKeyFile(self, file, algo):
        self._validateAlgo(algo)

        if algo not in file:
            raise RestException('This file does not have the %s hash computed.' % algo)
        hash = file[algo]
        name = '.'.join((file['name'], algo))

        setResponseHeader('Content-Length', len(hash))
        setResponseHeader('Content-Type', 'text/plain')
        setResponseHeader('Content-Disposition', 'attachment; filename="%s"' % name)
        setRawResponse()

        return hash
예제 #18
0
 def getDZITile(self, item, level, xandy, params):
     _adjustParams(params)
     tilesize = int(params.get('tilesize', 256))
     if tilesize & (tilesize - 1):
         raise RestException('Invalid tilesize', code=400)
     overlap = int(params.get('overlap', 0))
     if overlap < 0:
         raise RestException('Invalid overlap', code=400)
     x, y = [int(xy) for xy in xandy.split('.')[0].split('_')]
     _handleETag('getDZITile', item, level, xandy, params)
     metadata = self.imageItemModel.getMetadata(item, **params)
     level = int(level)
     maxlevel = int(math.ceil(math.log(max(
         metadata['sizeX'], metadata['sizeY'])) / math.log(2)))
     if level < 1 or level > maxlevel:
         raise RestException('level must be between 1 and the image scale',
                             code=400)
     lfactor = 2 ** (maxlevel - level)
     region = {
         'left': (x * tilesize - overlap) * lfactor,
         'top': (y * tilesize - overlap) * lfactor,
         'right': ((x + 1) * tilesize + overlap) * lfactor,
         'bottom': ((y + 1) * tilesize + overlap) * lfactor,
     }
     width = height = tilesize + overlap * 2
     if region['left'] < 0:
         width += int(region['left'] / lfactor)
         region['left'] = 0
     if region['top'] < 0:
         height += int(region['top'] / lfactor)
         region['top'] = 0
     if region['left'] >= metadata['sizeX']:
         raise RestException('x is outside layer', code=400)
     if region['top'] >= metadata['sizeY']:
         raise RestException('y is outside layer', code=400)
     if region['left'] < metadata['sizeX'] and region['right'] > metadata['sizeX']:
         region['right'] = metadata['sizeX']
         width = int(math.ceil(float(region['right'] - region['left']) / lfactor))
     if region['top'] < metadata['sizeY'] and region['bottom'] > metadata['sizeY']:
         region['bottom'] = metadata['sizeY']
         height = int(math.ceil(float(region['bottom'] - region['top']) / lfactor))
     regionData, regionMime = self.imageItemModel.getRegion(
         item,
         region=region,
         output=dict(maxWidth=width, maxHeight=height),
         **params)
     setResponseHeader('Content-Type', regionMime)
     setRawResponse()
     return regionData
예제 #19
0
    def renderAnnotation(self, annotation, params):
        contentDisp = params.get('contentDisposition', None)
        if contentDisp is not None and contentDisp not in {
                'inline', 'attachment'
        }:
            raise ValidationException(
                'Unallowed contentDisposition type "%s".' % contentDisp,
                'contentDisposition')

        self.requireParams(['featureId'], params)
        featureId = params['featureId']

        study = Study().load(annotation['meta']['studyId'],
                             force=True,
                             exc=True)
        featureset = Study().getFeatureset(study)

        if not any(featureId == feature['id']
                   for feature in featureset['localFeatures']):
            raise ValidationException('Invalid featureId.', 'featureId')
        if Annotation().getState(annotation) != Study().State.COMPLETE:
            raise RestException('Only complete annotations can be rendered.')

        renderData = Annotation().renderAnnotation(annotation, featureId)

        renderEncodedStream = ScikitSegmentationHelper.writeImage(
            renderData, 'jpeg')
        renderEncodedData = renderEncodedStream.getvalue()

        # Only setRawResponse now, as this handler may return a JSON error
        # earlier
        setRawResponse()
        setResponseHeader('Content-Type', 'image/jpeg')
        contentName = '%s_%s_annotation.jpg' % (
            annotation['_id'],
            featureId.replace('/',
                              ',')  # TODO: replace with a better character
        )
        if contentDisp == 'inline':
            setResponseHeader('Content-Disposition',
                              'inline; filename="%s"' % contentName)
        else:
            setResponseHeader('Content-Disposition',
                              'attachment; filename="%s"' % contentName)
        setResponseHeader('Content-Length', len(renderEncodedData))

        return renderEncodedData
예제 #20
0
    def renderAnnotation(self, annotation, params):
        Study = self.model('study', 'isic_archive')
        Annotation = self.model('annotation', 'isic_archive')
        contentDisp = params.get('contentDisposition', None)
        if contentDisp is not None and contentDisp not in {'inline', 'attachment'}:
            raise ValidationException('Unallowed contentDisposition type "%s".' % contentDisp,
                                      'contentDisposition')

        self.requireParams(['featureId'], params)
        featureId = params['featureId']

        study = Study.load(annotation['meta']['studyId'], force=True, exc=True)
        featureset = Study.getFeatureset(study)

        if not any(featureId == feature['id'] for feature in featureset['localFeatures']):
            raise ValidationException('Invalid featureId.', 'featureId')
        if Annotation.getState(annotation) != Study.State.COMPLETE:
            raise RestException('Only complete annotations can be rendered.')

        renderData = Annotation.renderAnnotation(annotation, featureId)

        renderEncodedStream = ScikitSegmentationHelper.writeImage(renderData, 'jpeg')
        renderEncodedData = renderEncodedStream.getvalue()

        # Only setRawResponse now, as this handler may return a JSON error
        # earlier
        setRawResponse()
        setResponseHeader('Content-Type', 'image/jpeg')
        contentName = '%s_%s_annotation.jpg' % (
            annotation['_id'],
            featureId.replace('/', ',')  # TODO: replace with a better character
        )
        if contentDisp == 'inline':
            setResponseHeader(
                'Content-Disposition',
                'inline; filename="%s"' % contentName)
        else:
            setResponseHeader(
                'Content-Disposition',
                'attachment; filename="%s"' % contentName)
        setResponseHeader('Content-Length', len(renderEncodedData))

        return renderEncodedData
예제 #21
0
 def pathRedirect(self, path):
     user = self.getCurrentUser()
     # Find the longest path that is a valid resource
     used = len(path)
     while used:
         try:
             resource = path_util.lookUpPath('/'.join(path[:used]), user)['document']
             break
         except path_util.ResourcePathNotFound:
             if used == 1:
                 raise
             used -= 1
     path = [resource['_modelType'], str(resource['_id'])] + list(path[used:])
     path_info = ('/'.join(cherrypy.request.path_info.split('/')[:2] + path))
     # This locates the redirected handler
     cherrypy.request.get_resource(path_info)
     result = cherrypy.request.handler()
     setRawResponse()
     return result
예제 #22
0
 def getTilesThumbnail(self, item, params):
     params = self._parseParams(params, True, [
         ('width', int),
         ('height', int),
         ('jpegQuality', int),
         ('jpegSubsampling', int),
         ('encoding', str),
     ])
     try:
         result = self.imageItemModel.getThumbnail(item, **params)
     except TileGeneralException as e:
         raise RestException(e.message)
     except ValueError as e:
         raise RestException('Value Error: %s' % e.message)
     if not isinstance(result, tuple):
         return result
     thumbData, thumbMime = result
     setResponseHeader('Content-Type', thumbMime)
     setRawResponse()
     return thumbData
예제 #23
0
 def getTilesThumbnail(self, item, params):
     params = self._parseParams(params, True, [
         ('width', int),
         ('height', int),
         ('jpegQuality', int),
         ('jpegSubsampling', int),
         ('encoding', str),
     ])
     try:
         result = self.imageItemModel.getThumbnail(item, **params)
     except TileGeneralException as e:
         raise RestException(e.message)
     except ValueError as e:
         raise RestException('Value Error: %s' % e.message)
     if not isinstance(result, tuple):
         return result
     thumbData, thumbMime = result
     setResponseHeader('Content-Type', thumbMime)
     setRawResponse()
     return thumbData
예제 #24
0
    def processTask(self, params=None):
        """
        Based on the process name in the URL and JSON in the request body,
        create & send a WPS request and pass on the response.
        """

        json_body = self.getBodyJson()

        process = json.loads(json.dumps(json_body), object_hook=deserialize)

        # assume output is GeoJSON or GeoTIFF
        process.compute()
        if process.output.default_output == gaia.formats.PANDAS:
            result = json.loads(process.output.read(format=gaia.formats.JSON))
        else:
            result = json.loads(process.output.read())
        if not isinstance(result, dict):
            setRawResponse(True)
            cherrypy.response.headers['Content-Type'] = 'image/tiff'
        return result
예제 #25
0
파일: geoprocess.py 프로젝트: jbeezley/gaia
    def processTask(self, params):
        """
        Based on the process name in the URL and JSON in the request body,
        create & send a WPS request and pass on the response.
        """

        json_body = self.getBodyJson()

        process = json.loads(json.dumps(json_body),
                             object_hook=deserialize)

        # assume output is GeoJSON or GeoTIFF
        process.compute()
        if process.output.default_output == gaia.formats.PANDAS:
            result = json.loads(process.output.read(format=gaia.formats.JSON))
        else:
            result = json.loads(process.output.read())
        if not isinstance(result, dict):
            setRawResponse(True)
            cherrypy.response.headers['Content-Type'] = 'image/tiff'
        return result
예제 #26
0
 def getTilesRegion(self, item, params):
     _adjustParams(params)
     params = self._parseParams(params, True, [
         ('left', float, 'region', 'left'),
         ('top', float, 'region', 'top'),
         ('right', float, 'region', 'right'),
         ('bottom', float, 'region', 'bottom'),
         ('regionWidth', float, 'region', 'width'),
         ('regionHeight', float, 'region', 'height'),
         ('units', str, 'region', 'units'),
         ('unitsWH', str, 'region', 'unitsWH'),
         ('width', int, 'output', 'maxWidth'),
         ('height', int, 'output', 'maxHeight'),
         ('fill', str),
         ('magnification', float, 'scale', 'magnification'),
         ('mm_x', float, 'scale', 'mm_x'),
         ('mm_y', float, 'scale', 'mm_y'),
         ('exact', bool, 'scale', 'exact'),
         ('frame', int),
         ('encoding', str),
         ('jpegQuality', int),
         ('jpegSubsampling', int),
         ('tiffCompression', str),
         ('style', str),
         ('resample', 'boolOrInt'),
         ('contentDisposition', str),
     ])
     _handleETag('getTilesRegion', item, params)
     try:
         regionData, regionMime = self.imageItemModel.getRegion(
             item, **params)
     except TileGeneralException as e:
         raise RestException(e.args[0])
     except ValueError as e:
         raise RestException('Value Error: %s' % e.args[0])
     self._setContentDisposition(
         item, params.get('contentDisposition'), regionMime, 'region')
     setResponseHeader('Content-Type', regionMime)
     setRawResponse()
     return regionData
예제 #27
0
    def thumbnail(self, segmentation, params):
        contentDisp = params.get('contentDisposition', None)
        if contentDisp is not None and contentDisp not in {
                'inline', 'attachment'
        }:
            raise ValidationException(
                'Unallowed contentDisposition type "%s".' % contentDisp,
                'contentDisposition')

        # TODO: convert this to make Segmentation use an AccessControlMixin
        image = Image().load(segmentation['imageId'],
                             level=AccessType.READ,
                             user=self.getCurrentUser(),
                             exc=True)

        width = int(params.get('width', 256))

        thumbnailImageStream = Segmentation().boundaryThumbnail(
            segmentation, image, width)
        if thumbnailImageStream is None:
            raise RestException(
                'This segmentation is failed, and thus has no thumbnail.',
                code=410)
        thumbnailImageData = thumbnailImageStream.getvalue()

        # Only setRawResponse now, as this handler may return a JSON error
        # earlier
        setRawResponse()
        setResponseHeader('Content-Type', 'image/jpeg')
        contentName = '%s_segmentation_thumbnail.jpg' % image['name']
        if contentDisp == 'inline':
            setResponseHeader('Content-Disposition',
                              'inline; filename="%s"' % contentName)
        else:
            setResponseHeader('Content-Disposition',
                              'attachment; filename="%s"' % contentName)
        setResponseHeader('Content-Length', len(thumbnailImageData))

        return thumbnailImageData
예제 #28
0
    def _getTile(self, item, z, x, y, imageArgs, mayRedirect=False):
        """
        Get an large image tile.

        :param item: the item to get a tile from.
        :param z: tile layer number (0 is the most zoomed-out).
        .param x: the X coordinate of the tile (0 is the left side).
        .param y: the Y coordinate of the tile (0 is the top).
        :param imageArgs: additional arguments to use when fetching image data.
        :param mayRedirect: if True or one of 'any', 'encoding', or 'exact',
            allow return a response whcih may be a redirect.
        :return: a function that returns the raw image data.
        """
        try:
            x, y, z = int(x), int(y), int(z)
        except ValueError:
            raise RestException('x, y, and z must be integers', code=400)
        if x < 0 or y < 0 or z < 0:
            raise RestException('x, y, and z must be positive integers',
                                code=400)
        result = self.imageItemModel._tileFromHash(item,
                                                   x,
                                                   y,
                                                   z,
                                                   mayRedirect=mayRedirect,
                                                   **imageArgs)
        if result is not None:
            tileData, tileMime = result
        else:
            try:
                tileData, tileMime = self.imageItemModel.getTile(
                    item, x, y, z, mayRedirect=mayRedirect, **imageArgs)
            except TileGeneralException as e:
                raise RestException(e.args[0], code=404)
        setResponseHeader('Content-Type', tileMime)
        setRawResponse()
        return tileData
 def getItemXML(self, item):
     setResponseHeader('Content-Type', 'application/xml')
     setRawResponse()
     return CLIItem(item).xml
 def getXMLSpecHandler(self, *args, **kwargs):
     setResponseHeader('Content-Type', 'application/xml')
     setRawResponse()
     return str_xml
예제 #31
0
    def getTilesRegion(self, item, params):

        _adjustParams(params)
        params = self._parseParams(params, True, [
            ('left', float, 'region', 'left'),
            ('top', float, 'region', 'top'),
            ('right', float, 'region', 'right'),
            ('bottom', float, 'region', 'bottom'),
            ('regionWidth', float, 'region', 'width'),
            ('regionHeight', float, 'region', 'height'),
            ('units', str, 'region', 'units'),
            ('unitsWH', str, 'region', 'unitsWH'),
            ('width', int, 'output', 'maxWidth'),
            ('height', int, 'output', 'maxHeight'),
            ('fill', str),
            ('magnification', float, 'scale', 'magnification'),
            ('mm_x', float, 'scale', 'mm_x'),
            ('mm_y', float, 'scale', 'mm_y'),
            ('exact', bool, 'scale', 'exact'),
            ('frame', int),
            ('encoding', str),
            ('jpegQuality', int),
            ('jpegSubsampling', int),
            ('tiffCompression', str),
            ('style', str),
            ('resample', 'boolOrInt'),
            ('contentDisposition', str),
            ('contentDispositionFileName', str)
        ])
        _handleETag('getTilesRegion', item, params)
        setResponseTimeLimit(86400)
        try:
            regionData, regionMime = self.imageItemModel.getRegion(
                item, **params)
        except TileGeneralException as e:
            raise RestException(e.args[0])
        except ValueError as e:
            raise RestException('Value Error: %s' % e.args[0])

        subname = str(int(params.get('region')['left'])) + ',' + str(int(params.get('region')['top']))

        self._setContentDisposition(
            item, params.get('contentDisposition'), regionMime, subname,
            params.get('contentDispositionFilename'))
        setResponseHeader('Content-Type', regionMime)

        if isinstance(regionData, pathlib.Path):
            BUF_SIZE = 65536

            def stream():
                try:
                    with regionData.open('rb') as f:
                        while True:
                            data = f.read(BUF_SIZE)
                            if not data:
                                break
                            yield data
                finally:
                    regionData.unlink()
            return stream
        setRawResponse()
        return regionData