void tiff_reader<T>::read_stripped(unsigned x0,unsigned y0,image_data_32& image)
{
TIFF* tif = open(stream_);
if (tif)
{
uint32* buf = (uint32*)_TIFFmalloc(width_*rows_per_strip_*sizeof(uint32));
int width=image.width();
int height=image.height();
unsigned start_y=(y0/rows_per_strip_)*rows_per_strip_;
unsigned end_y=((y0+height)/rows_per_strip_+1)*rows_per_strip_;
bool laststrip=((unsigned)end_y > height_)?true:false;
int row,tx0,tx1,ty0,ty1;
tx0=x0;
tx1=std::min(width+x0,(unsigned)width_);
for (unsigned y=start_y; y < end_y; y+=rows_per_strip_)
{
ty0 = std::max(y0,y)-y;
ty1 = std::min(height+y0,y+rows_per_strip_)-y;
if (!TIFFReadRGBAStrip(tif,y,buf)) break;
row=y+ty0-y0;
int n0=laststrip ? 0:(rows_per_strip_-ty1);
int n1=laststrip ? (ty1-ty0-1):(rows_per_strip_-ty0-1);
for (int n=n1;n>=n0;--n)
{
image.setRow(row,tx0-x0,tx1-x0,(const unsigned*)&buf[n*width_+tx0]);
++row;
}
}
_TIFFfree(buf);
}
}
bool TiffDecoder::readData( Mat& img )
{
bool result = false;
bool color = img.channels() > 1;
uchar* data = img.data;
int step = (int)img.step;
if( img.depth() != CV_8U && img.depth() != CV_16U && img.depth() != CV_32F && img.depth() != CV_64F )
return false;
if( m_tif && m_width && m_height )
{
TIFF* tif = (TIFF*)m_tif;
int tile_width0 = m_width, tile_height0 = 0;
int x, y, i;
int is_tiled = TIFFIsTiled(tif);
int photometric;
TIFFGetField( tif, TIFFTAG_PHOTOMETRIC, &photometric );
int bpp = 8, ncn = photometric > 1 ? 3 : 1;
TIFFGetField( tif, TIFFTAG_BITSPERSAMPLE, &bpp );
TIFFGetField( tif, TIFFTAG_SAMPLESPERPIXEL, &ncn );
const int bitsPerByte = 8;
int dst_bpp = (int)(img.elemSize1() * bitsPerByte);
if(dst_bpp == 8)
{
char errmsg[1024];
if(!TIFFRGBAImageOK( tif, errmsg ))
{
close();
return false;
}
}
if( (!is_tiled) ||
(is_tiled &&
TIFFGetField( tif, TIFFTAG_TILEWIDTH, &tile_width0 ) &&
TIFFGetField( tif, TIFFTAG_TILELENGTH, &tile_height0 )))
{
if(!is_tiled)
TIFFGetField( tif, TIFFTAG_ROWSPERSTRIP, &tile_height0 );
if( tile_width0 <= 0 )
tile_width0 = m_width;
if( tile_height0 <= 0 )
tile_height0 = m_height;
AutoBuffer<uchar> _buffer(tile_height0*tile_width0*8);
uchar* buffer = _buffer;
ushort* buffer16 = (ushort*)buffer;
float* buffer32 = (float*)buffer;
double* buffer64 = (double*)buffer;
int tileidx = 0;
for( y = 0; y < m_height; y += tile_height0, data += step*tile_height0 )
{
int tile_height = tile_height0;
if( y + tile_height > m_height )
tile_height = m_height - y;
for( x = 0; x < m_width; x += tile_width0, tileidx++ )
{
int tile_width = tile_width0, ok;
if( x + tile_width > m_width )
tile_width = m_width - x;
switch(dst_bpp)
{
case 8:
{
if( !is_tiled )
ok = TIFFReadRGBAStrip( tif, y, (uint32*)buffer );
else
ok = TIFFReadRGBATile( tif, x, y, (uint32*)buffer );
if( !ok )
{
close();
return false;
}
for( i = 0; i < tile_height; i++ )
if( color )
icvCvt_BGRA2BGR_8u_C4C3R( buffer + i*tile_width*4, 0,
data + x*3 + step*(tile_height - i - 1), 0,
cvSize(tile_width,1), 2 );
else
icvCvt_BGRA2Gray_8u_C4C1R( buffer + i*tile_width*4, 0,
data + x + step*(tile_height - i - 1), 0,
cvSize(tile_width,1), 2 );
break;
}
case 16:
{
if( !is_tiled )
ok = (int)TIFFReadEncodedStrip( tif, tileidx, (uint32*)buffer, (tsize_t)-1 ) >= 0;
else
ok = (int)TIFFReadEncodedTile( tif, tileidx, (uint32*)buffer, (tsize_t)-1 ) >= 0;
if( !ok )
{
close();
return false;
}
for( i = 0; i < tile_height; i++ )
{
if( color )
{
if( ncn == 1 )
{
icvCvt_Gray2BGR_16u_C1C3R(buffer16 + i*tile_width*ncn, 0,
(ushort*)(data + step*i) + x*3, 0,
cvSize(tile_width,1) );
}
else if( ncn == 3 )
{
icvCvt_RGB2BGR_16u_C3R(buffer16 + i*tile_width*ncn, 0,
(ushort*)(data + step*i) + x*3, 0,
cvSize(tile_width,1) );
}
else
{
icvCvt_BGRA2BGR_16u_C4C3R(buffer16 + i*tile_width*ncn, 0,
(ushort*)(data + step*i) + x*3, 0,
cvSize(tile_width,1), 2 );
}
}
else
{
if( ncn == 1 )
{
memcpy((ushort*)(data + step*i)+x,
buffer16 + i*tile_width*ncn,
tile_width*sizeof(buffer16[0]));
}
else
{
icvCvt_BGRA2Gray_16u_CnC1R(buffer16 + i*tile_width*ncn, 0,
(ushort*)(data + step*i) + x, 0,
cvSize(tile_width,1), ncn, 2 );
}
}
}
break;
}
case 32:
case 64:
{
if( !is_tiled )
ok = (int)TIFFReadEncodedStrip( tif, tileidx, buffer, (tsize_t)-1 ) >= 0;
else
ok = (int)TIFFReadEncodedTile( tif, tileidx, buffer, (tsize_t)-1 ) >= 0;
if( !ok || ncn != 1 )
{
close();
return false;
}
for( i = 0; i < tile_height; i++ )
{
if(dst_bpp == 32)
{
memcpy((float*)(data + step*i)+x,
buffer32 + i*tile_width*ncn,
tile_width*sizeof(buffer32[0]));
}
else
{
memcpy((double*)(data + step*i)+x,
buffer64 + i*tile_width*ncn,
tile_width*sizeof(buffer64[0]));
}
}
break;
}
default:
{
close();
return false;
}
}
}
}
result = true;
}
}
close();
return result;
}
static int
cvt_by_strip( TIFF *in, TIFF *out )
{
uint32* raster; /* retrieve RGBA image */
uint32 width, height; /* image width & height */
uint32 row;
uint32 *wrk_line;
int ok = 1;
TIFFGetField(in, TIFFTAG_IMAGEWIDTH, &width);
TIFFGetField(in, TIFFTAG_IMAGELENGTH, &height);
if( !TIFFGetField(in, TIFFTAG_ROWSPERSTRIP, &rowsperstrip) ) {
TIFFError(TIFFFileName(in), "Source image not in strips");
return (0);
}
TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
/*
* Allocate strip buffer
*/
raster = (uint32*)_TIFFmalloc(width * rowsperstrip * sizeof (uint32));
if (raster == 0) {
TIFFError(TIFFFileName(in), "No space for raster buffer");
return (0);
}
/*
* Allocate a scanline buffer for swapping during the vertical
* mirroring pass.
*/
wrk_line = (uint32*)_TIFFmalloc(width * sizeof (uint32));
if (!wrk_line) {
TIFFError(TIFFFileName(in), "No space for raster scanline buffer");
ok = 0;
}
/*
* Loop over the strips.
*/
for( row = 0; ok && row < height; row += rowsperstrip )
{
int rows_to_write, i_row;
/* Read the strip into an RGBA array */
if (!TIFFReadRGBAStrip(in, row, raster)) {
ok = 0;
break;
}
/*
* Figure out the number of scanlines actually in this strip.
*/
if( row + rowsperstrip > height )
rows_to_write = height - row;
else
rows_to_write = rowsperstrip;
/*
* For some reason the TIFFReadRGBAStrip() function chooses the
* lower left corner as the origin. Vertically mirror scanlines.
*/
for( i_row = 0; i_row < rows_to_write / 2; i_row++ )
{
uint32 *top_line, *bottom_line;
top_line = raster + width * i_row;
bottom_line = raster + width * (rows_to_write-i_row-1);
_TIFFmemcpy(wrk_line, top_line, 4*width);
_TIFFmemcpy(top_line, bottom_line, 4*width);
_TIFFmemcpy(bottom_line, wrk_line, 4*width);
}
/*
* Write out the result in a strip
*/
if( TIFFWriteEncodedStrip( out, row / rowsperstrip, raster,
4 * rows_to_write * width ) == -1 )
{
ok = 0;
break;
}
}
_TIFFfree( raster );
_TIFFfree( wrk_line );
return ok;
}
static int
cvt_by_strip( TIFF *in, TIFF *out )
{
uint32* raster; /* retrieve RGBA image */
uint32 width, height; /* image width & height */
uint32 row;
uint32 *wrk_line;
tsize_t raster_size;
int ok = 1;
TIFFGetField(in, TIFFTAG_IMAGEWIDTH, &width);
TIFFGetField(in, TIFFTAG_IMAGELENGTH, &height);
if( !TIFFGetField(in, TIFFTAG_ROWSPERSTRIP, &rowsperstrip) ) {
TIFFError(TIFFFileName(in), "Source image not in strips");
return (0);
}
TIFFSetField(out, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
/*
* Allocate strip buffer
*/
raster_size = multiply(multiply(width, rowsperstrip), sizeof (uint32));
if (!raster_size) {
TIFFError(TIFFFileName(in),
"Can't allocate buffer for raster of size %lux%lu",
(unsigned long) width, (unsigned long) rowsperstrip);
return (0);
}
raster = (uint32*)_TIFFmalloc(raster_size);
if (raster == 0) {
TIFFError(TIFFFileName(in), "No space for raster buffer");
return (0);
}
/*
* Allocate a scanline buffer for swapping during the vertical
* mirroring pass. (Request can't overflow given prior checks.)
*/
wrk_line = (uint32*)_TIFFmalloc(width * sizeof (uint32));
if (!wrk_line) {
TIFFError(TIFFFileName(in), "No space for raster scanline buffer");
ok = 0;
}
/*
* Loop over the strips.
*/
for( row = 0; ok && row < height; row += rowsperstrip )
{
int rows_to_write, i_row;
/* Read the strip into an RGBA array */
if (!TIFFReadRGBAStrip(in, row, raster)) {
ok = 0;
break;
}
/*
* XXX: raster array has 4-byte unsigned integer type, that is why
* we should rearrange it here.
*/
#if HOST_BIGENDIAN
TIFFSwabArrayOfLong(raster, width * rowsperstrip);
#endif
/*
* Figure out the number of scanlines actually in this strip.
*/
if( row + rowsperstrip > height )
rows_to_write = height - row;
else
rows_to_write = rowsperstrip;
/*
* For some reason the TIFFReadRGBAStrip() function chooses the
* lower left corner as the origin. Vertically mirror scanlines.
*/
for( i_row = 0; i_row < rows_to_write / 2; i_row++ )
{
uint32 *top_line, *bottom_line;
top_line = raster + width * i_row;
bottom_line = raster + width * (rows_to_write-i_row-1);
_TIFFmemcpy(wrk_line, top_line, 4*width);
_TIFFmemcpy(top_line, bottom_line, 4*width);
_TIFFmemcpy(bottom_line, wrk_line, 4*width);
}
/*
* Write out the result in a strip
*/
if( TIFFWriteEncodedStrip( out, row / rowsperstrip, raster,
4 * rows_to_write * width ) == -1 )
{
ok = 0;
break;
}
}
_TIFFfree( raster );
_TIFFfree( wrk_line );
return ok;
}
void TifReader::readLine(char *buffer, int x0, int x1, int shrink)
{
if (this->m_info.m_bitsPerSample == 16 && this->m_info.m_samplePerPixel >= 3) {
std::vector<short> app(4 * (m_info.m_lx));
readLine(&app[0], x0, x1, shrink);
TPixel64 *pixin = (TPixel64 *)&app[0];
TPixel32 *pixout = (TPixel32 *)buffer;
for (int j = 0; j < x0; j++) {
pixout++;
pixin++;
}
for (int i = 0; i < (x1 - x0) + 1; i++)
*pixout++ = PixelConverter<TPixel32>::from(*pixin++);
return;
}
assert(shrink > 0);
const int pixelSize = 4;
int stripRowSize = m_rowLength * pixelSize;
if (m_row < m_info.m_y0 || m_row > m_info.m_y1) {
memset(buffer, 0, (x1 - x0 + 1) * pixelSize);
m_row++;
return;
}
int stripIndex = m_row / m_rowsPerStrip;
if (m_stripIndex != stripIndex) {
m_stripIndex = stripIndex;
if (TIFFIsTiled(m_tiff)) {
uint32 tileWidth = 0, tileHeight = 0;
TIFFGetField(m_tiff, TIFFTAG_TILEWIDTH, &tileWidth);
TIFFGetField(m_tiff, TIFFTAG_TILELENGTH, &tileHeight);
assert(tileWidth > 0 && tileHeight > 0);
int tileSize = tileWidth * tileHeight;
std::unique_ptr<uint32[]> tile(new uint32[tileSize]);
int x = 0;
int y = tileHeight * m_stripIndex;
int lastTy = std::min((int)tileHeight, m_info.m_ly - y);
while (x < m_info.m_lx) {
int ret = TIFFReadRGBATile(m_tiff, x, y, tile.get());
assert(ret);
int tileRowSize = std::min((int)tileWidth, (int)(m_info.m_lx - x)) * pixelSize;
for (int ty = 0; ty < lastTy; ++ty) {
memcpy(
m_stripBuffer + (ty * m_rowLength + x) * pixelSize,
(UCHAR *)tile.get() + ty * tileWidth * pixelSize,
tileRowSize);
}
x += tileWidth;
}
} else {
int y = m_rowsPerStrip * m_stripIndex;
int ok = TIFFReadRGBAStrip(m_tiff, y, (uint32 *)m_stripBuffer);
assert(ok);
}
}
uint16 orient = ORIENTATION_TOPLEFT;
TIFFGetField(m_tiff, TIFFTAG_ORIENTATION, &orient);
int r = m_rowsPerStrip - 1 - (m_row % m_rowsPerStrip);
switch (orient) // Pretty weak check for top/bottom orientation
{
case ORIENTATION_TOPLEFT:
case ORIENTATION_TOPRIGHT:
case ORIENTATION_LEFTTOP:
case ORIENTATION_RIGHTTOP:
// We have to invert the fixed BOTTOM-UP returned by TIFF functions - since this function is
// supposed to ignore orientation issues (which are managed outside).
// The last tiles row will actually start at the END OF THE IMAGE (not necessarily at
// m_rowsPerStrip multiples). So, we must adjust for that.
r = std::min(m_rowsPerStrip, m_info.m_ly - m_rowsPerStrip * m_stripIndex) - 1 -
(m_row % m_rowsPerStrip);
break;
case ORIENTATION_BOTRIGHT:
case ORIENTATION_BOTLEFT:
case ORIENTATION_RIGHTBOT:
case ORIENTATION_LEFTBOT:
r = m_row % m_rowsPerStrip;
break;
}
TPixel32 *pix = (TPixel32 *)buffer;
uint32 *v = (uint32 *)(m_stripBuffer + r * stripRowSize);
pix += x0;
v += x0;
int width = (x1 < x0) ? (m_info.m_lx - 1) / shrink + 1 : (x1 - x0) / shrink + 1;
for (int i = 0; i < width; i++) {
uint32 c = *v;
pix->r = (UCHAR)TIFFGetR(c);
pix->g = (UCHAR)TIFFGetG(c);
pix->b = (UCHAR)TIFFGetB(c);
pix->m = (UCHAR)TIFFGetA(c);
v += shrink;
pix += shrink;
}
m_row++;
}
bool TiffDecoder::readData( Mat& img )
{
bool result = false;
bool color = img.channels() > 1;
uchar* data = img.data;
int step = img.step;
if( m_tif && m_width && m_height )
{
TIFF* tif = (TIFF*)m_tif;
int tile_width0 = m_width, tile_height0 = 0;
int x, y, i;
int is_tiled = TIFFIsTiled(tif);
if( (!is_tiled &&
TIFFGetField( tif, TIFFTAG_ROWSPERSTRIP, &tile_height0 )) ||
(is_tiled &&
TIFFGetField( tif, TIFFTAG_TILEWIDTH, &tile_width0 ) &&
TIFFGetField( tif, TIFFTAG_TILELENGTH, &tile_height0 )))
{
if( tile_width0 <= 0 )
tile_width0 = m_width;
if( tile_height0 <= 0 )
tile_height0 = m_height;
AutoBuffer<uchar> _buffer(tile_height0*tile_width0*4);
uchar* buffer = _buffer;
for( y = 0; y < m_height; y += tile_height0, data += step*tile_height0 )
{
int tile_height = tile_height0;
if( y + tile_height > m_height )
tile_height = m_height - y;
for( x = 0; x < m_width; x += tile_width0 )
{
int tile_width = tile_width0, ok;
if( x + tile_width > m_width )
tile_width = m_width - x;
if( !is_tiled )
ok = TIFFReadRGBAStrip( tif, y, (uint32*)buffer );
else
ok = TIFFReadRGBATile( tif, x, y, (uint32*)buffer );
if( !ok )
{
close();
return false;
}
for( i = 0; i < tile_height; i++ )
if( color )
icvCvt_BGRA2BGR_8u_C4C3R( buffer + i*tile_width*4, 0,
data + x*3 + step*(tile_height - i - 1), 0,
cvSize(tile_width,1), 2 );
else
icvCvt_BGRA2Gray_8u_C4C1R( buffer + i*tile_width*4, 0,
data + x + step*(tile_height - i - 1), 0,
cvSize(tile_width,1), 2 );
}
}
result = true;
}
}
close();
return result;
}
