def asarray(self, squeeze=True, colormapped=True, rgbonly=True):
        """Read image data from file and return as numpy array.

        Raise ValueError if format is unsupported.
        If any argument is False, the shape of the returned array might be
        different from the page shape.

        Parameters
        ----------
        squeeze : bool
            If True all length-1 dimensions (except X and Y) are
            squeezed out from result.
        colormapped : bool
            If True color mapping is applied for palette-indexed images.
        rgbonly : bool
            If True return RGB(A) image without additional extra samples.

        """
        fd = self.parent._fd
        if not fd:
            raise IOError("TIFF file is not open")
        if self.dtype is None:
            raise ValueError("data type not supported: %s%i" % (
                self.sample_format, self.bits_per_sample))
        if self.compression not in TIFF_DECOMPESSORS:
            raise ValueError("cannot decompress %s" % self.compression)
        if ('ycbcr_subsampling' in self.tags and
            self.tags['ycbcr_subsampling'].value not in (1, (1, 1))):
            raise ValueError("YCbCr subsampling not supported")
        tag = self.tags['sample_format']
        if tag.count != 1 and any((i-tag.value[0] for i in tag.value)):
            raise ValueError("sample formats don't match %s" % str(tag.value))

        dtype = self._dtype
        shape = self._shape
        image_width = self.image_width
        image_length = self.image_length
        typecode = self.parent.byte_order + dtype
        bits_per_sample = self.bits_per_sample

        if self.is_tiled:
            if 'tile_offsets' in self.tags:
                byte_counts = self.tile_byte_counts
                offsets = self.tile_offsets
            else:
                byte_counts = self.strip_byte_counts
                offsets = self.strip_offsets
            tile_width = self.tile_width
            tile_length = self.tile_length
            tw = (image_width + tile_width - 1) // tile_width
            tl = (image_length + tile_length - 1) // tile_length
            shape = shape[:-3] + (tl*tile_length, tw*tile_width, shape[-1])
            tile_shape = (tile_length, tile_width, shape[-1])
            runlen = tile_width
        else:
            byte_counts = self.strip_byte_counts
            offsets = self.strip_offsets
            runlen = image_width

        try:
            offsets[0]
        except TypeError:
            offsets = (offsets, )
            byte_counts = (byte_counts, )
        if any(o < 2 for o in offsets):
            raise ValueError("corrupted file")

        if (not self.is_tiled and (self.is_stk or (not self.compression
            and bits_per_sample in (8, 16, 32, 64)
            and all(offsets[i] == offsets[i+1] - byte_counts[i]
                    for i in range(len(offsets)-1))))):
            # contiguous data
            fd.seek(offsets[0])
            result = numpy.fromfile(fd, typecode, numpy.prod(shape))
            result = result.astype('=' + dtype)
        else:
            if self.planar_configuration == 'contig':
                runlen *= self.samples_per_pixel
            if bits_per_sample in (8, 16, 32, 64, 128):
                if (bits_per_sample * runlen) % 8:
                    raise ValueError("data and sample size mismatch")
                unpack = lambda x: numpy.fromstring(x, typecode)
            elif isinstance(bits_per_sample, tuple):
                unpack = lambda x: unpackrgb(x, typecode, bits_per_sample)
            else:
                unpack = lambda x: unpackints(x, typecode, bits_per_sample,
                                              runlen)
            decompress = TIFF_DECOMPESSORS[self.compression]
            if self.is_tiled:
                result = numpy.empty(shape, dtype)
                tw, tl, pl = 0, 0, 0
                for offset, bytecount in zip(offsets, byte_counts):
                    fd.seek(offset)
                    tile = unpack(decompress(fd.read(bytecount)))
                    tile.shape = tile_shape
                    result[0, pl, tl:tl+tile_length,
                           tw:tw+tile_width, :] = tile
                    del tile
                    tw += tile_width
                    if tw >= shape[-2]:
                        tw, tl = 0, tl + tile_length
                        if tl >= shape[-3]:
                            tl, pl = 0, pl + 1
                result = result[..., :image_length, :image_width, :]
            else:
                result = numpy.empty(shape, dtype).reshape(-1)
                index = 0
                for offset, bytecount in zip(offsets, byte_counts):
                    fd.seek(offset)
                    stripe = unpack(decompress(fd.read(bytecount)))
                    size = min(result.size, stripe.size)
                    result[index:index+size] = stripe[:size]
                    del stripe
                    index += size

        result.shape = self._shape

        if self.predictor == 'horizontal':
            # workaround bug in LSM510 software
            if not (self.parent.is_lsm and not self.compression):
                numpy.cumsum(result, axis=3, dtype=dtype, out=result)

        if colormapped and self.is_palette:
            if self.color_map.shape[1] >= 2**bits_per_sample:
                # FluoView and LSM might fail here
                result = numpy.take(self.color_map, result, axis=1)
        elif rgbonly and self.is_rgb and 'extra_samples' in self.tags:
            # return only RGB and first alpha channel if exists
            extra_samples = self.extra_samples
            if self.tags['extra_samples'].count == 1:
                extra_samples = (extra_samples, )
            for i, exs in enumerate(extra_samples):
                if exs in ('unassalpha', 'assocalpha'):
                    if self.planar_configuration == 'contig':
                        result = result[..., [0, 1, 2, 3+i]]
                    else:
                        result = result[:, [0, 1, 2, 3+i]]
                    break
            else:
                if self.planar_configuration == 'contig':
                    result = result[..., :3]
                else:
                    result = result[:, :3]

        if squeeze:
            try:
                result.shape = self.shape
            except ValueError:
                pass

        return result