pyFLIF/flif_image_decoding.py at master · charun80/pyFLIF · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
# -*- coding: utf-8 -*-
"""
Created on Thu Jan 25 18:09:13 2018

@author: Matthias Höffken
"""

from __future__ import print_function


__all__ = ["flifDecoderImage", "flifDecoder"]


import ctypes as ct
import numpy as np
from flif_wrapper_common import flifImageBase, flifDecoderBase

####################################################################################

# Logging

import logging
Logger = logging.getLogger("FLIF_Decoder")
Logger.setLevel("WARN")


####################################################################################


class flifDecoderImage( flifImageBase ):

    mFlifImageHandle = None

    @property
    def width(self):        return self.flif.get_width( self.mFlifImageHandle )
    @property
    def height(self):       return self.flif.get_height( self.mFlifImageHandle )
    @property
    def nb_channels(self):  return self.flif.get_nb_channels( self.mFlifImageHandle )
    @property
    def depth(self):        return self.flif.get_depth( self.mFlifImageHandle )
    @property
    def palette_size(self): return self.flif.get_palette_size( self.mFlifImageHandle )


    rowReader = None
    dtype     = None
    mImgShape = None


    def __init__(self, flifImageHandle ):
        self.mFlifImageHandle = flifImageHandle

        if 0 != self.palette_size:
            raise ValueError("")

        dtype = (np.uint8, np.uint16)

        if 1 == self.nb_channels:
            rowReader = ( self.flif.read_row_GRAY8, self.flif.read_row_GRAY16 )
            self.mImgShape = (self.height, self.width)
        else:
            rowReader = ( self.flif.read_row_RGBA8, self.flif.read_row_RGBA16 )
            self.mImgShape = (self.height, self.width, 4)

        if 8 == self.depth:
            self.dtype = dtype[0]
            rowReader = rowReader[0]
        elif 16 == self.depth:
            self.dtype = dtype[1]
            rowReader = rowReader[1]
        else:
            assert( False )  # depth should be always 8 or 16

        self.rowReader = lambda rowIdx, Buffer, bufSize: \
                                rowReader( self.mFlifImageHandle, rowIdx, Buffer, bufSize )


    def getImage( self ):

        auxShape = (self.mImgShape[0], np.prod(self.mImgShape[1:] ))

        npyImg = np.zeros( auxShape, dtype=self.dtype )
        assert( npyImg.flags['C_CONTIGUOUS'] )

        imgPointer = npyImg.ctypes.data_as( ct.c_void_p )

        for rowIdx in xrange( npyImg.shape[0] ):
            self.rowReader( rowIdx, imgPointer, npyImg.strides[0] )
            imgPointer.value += npyImg.strides[0]   # jump to next row (strides in bytes)

        npyImg = npyImg.reshape( self.mImgShape )

        if (1 < self.nb_channels) and (4 != self.nb_channels):
            npyImg = npyImg[:,:,:self.nb_channels]

        return npyImg


class flifDecoder( flifDecoderBase ):


    # Object members
    mFlifDecoderHandle = None
    mFname = None


    def __init__(self, fname ):
        self.mFname = fname
        self.mFlifDecoderHandle = None


    def  __enter__(self):
        # create decoder
        self.mFlifDecoderHandle = self.flif.create_decoder()
        Logger.debug("Create FLIF decoder %r", self.mFlifDecoderHandle )

        # set CRC check
        self.flif.set_crc_check( self.mFlifDecoderHandle, 1 )

        # encode file
        if 0 == self.flif.decode_file( self.mFlifDecoderHandle, self.mFname ):
            raise IOError("Error decoding FLIF file %r" % self.mFname )

        Logger.debug("Decoded FLIF file %r", self.mFname )

        return self


    def __exit__(self, exc_type, exc_value, traceback):
        if self.mFlifDecoderHandle is not None:
            self.flif.destroy_decoder( self.mFlifDecoderHandle )
            self.mFlifDecoderHandle = None


    def numImages(self):
        if self.mFlifDecoderHandle is None:
            raise IOError( "FLIF file %r not (yet) decoded" % self.mFname )
        return self.flif.num_images( self.mFlifDecoderHandle )


    def getImage(self, index ):
        if index >= self.numImages():
            raise ValueError("Frame index %d out of %d requested" % (index, self.numImages) )

        # optain image pointer
        flifImageHandle = self.flif.get_image( self.mFlifDecoderHandle, index )

        if flifImageHandle is None:
            raise IOError("Error reading image %d" % index)

        return flifDecoderImage( flifImageHandle ).getImage()