Java example source code file (mlib_ImageColorTrue2Index.c)
The mlib_ImageColorTrue2Index.c Java example source code/*
* Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* FUNCTION
* mlib_ImageColorTrue2Index - convert a true color image to an indexed
* color image
*
* SYNOPSIS
* mlib_status mlib_ImageColorTrue2Index(mlib_image *dst,
* const mlib_image *src,
* const void *colormap)
*
* ARGUMENTS
* colormap Internal data structure for inverse color mapping.
* dst Pointer to destination image.
* src Pointer to source image.
*
* DESCRIPTION
* Convert a true color image to a pseudo color image with the method
* of finding the nearest matched lut entry for each pixel.
*
* The src can be an MLIB_BYTE or MLIB_SHORT image with 3 or 4 channels.
* The dst must be a 1-channel MLIB_BYTE or MLIB_SHORT image.
*
* The lut might have either 3 or 4 channels. The type of the lut can be
* one of the following:
* MLIB_BYTE in, MLIB_BYTE out (i.e., BYTE-to-BYTE)
* MLIB_BYTE in, MLIB_SHORT out (i.e., BYTE-to-SHORT)
* MLIB_SHORT in, MLIB_SHORT out (i.e., SHORT-to-SHORT)
* MLIB_SHORT in, MLIB_BYTE out (i.e., SHORT-to-BYTE)
*
* The src image and the lut must have same number of channels.
*/
#include "mlib_image.h"
#include "mlib_ImageColormap.h"
#include "mlib_ImageCheck.h"
/***************************************************************/
/*#define USE_VIS_CODE*/
#ifdef USE_VIS_CODE
#include "vis_proto.h"
#define VIS_ALIGNADDR(X, Y) vis_alignaddr((void *)(X), (Y))
#endif
/***************************************************************/
#define LUT_BYTE_COLORS_3CHANNELS 1000
#define LUT_BYTE_COLORS_4CHANNELS 3000
#define LUT_SHORT_COLORS_3CHANNELS 1000
#define LUT_SHORT_COLORS_4CHANNELS 1000
/***************************************************************/
#define MAIN_COLORTRUE2INDEX_LOOP( FROM_TYPE, TO_TYPE, NCHANNELS ) \
for( y = 0; y < height; y++ ) \
{ \
mlib_ImageColorTrue2IndexLine_##FROM_TYPE##_##TO_TYPE##_##NCHANNELS( \
sdata, ddata, width, colormap ); \
\
sdata += sstride; \
ddata += dstride; \
}
/***************************************************************/
#define COLOR_CUBE_U8_3_SEARCH( TABLE_POINTER_TYPE, SHIFT, STEP ) \
{ \
const mlib_u8 *c0, *c1, *c2; \
TABLE_POINTER_TYPE *table = s->table; \
mlib_s32 bits = s->bits; \
mlib_s32 nbits = 8 - bits; \
mlib_s32 mask = ~( ( 1 << nbits ) - 1 ); \
mlib_s32 j; \
\
c0 = src + SHIFT; \
c1 = src + 1 + SHIFT; \
c2 = src + 2 + SHIFT; \
\
switch( bits ) \
{ \
case 1: \
case 2: \
{ \
mlib_s32 bits0 = 8 - bits; \
mlib_s32 bits1 = bits0 - bits; \
mlib_s32 bits2 = bits1 - bits; \
\
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( *c0 & mask ) >> bits2 ) | \
( ( *c1 & mask ) >> bits1 ) | \
( ( *c2 & mask ) >> bits0 ) ]; \
\
c0 += STEP; \
c1 += STEP; \
c2 += STEP; \
} \
break; \
} \
case 3: \
{ \
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( *c0 & mask ) << 1 ) | \
( ( *c1 & mask ) >> 2 ) | \
( ( *c2 & mask ) >> 5 ) ]; \
\
c0 += STEP; \
c1 += STEP; \
c2 += STEP; \
} \
break; \
} \
case 4: \
{ \
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( *c0 & mask ) << 4 ) | \
( *c1 & mask ) | \
( ( *c2 & mask ) >> 4 ) ]; \
\
c0 += STEP; \
c1 += STEP; \
c2 += STEP; \
} \
break; \
} \
case 5: \
case 6: \
case 7: \
{ \
mlib_s32 bits0 = 8 - bits; \
mlib_s32 bits1 = bits * 2 - 8; \
mlib_s32 bits2 = bits1 + bits; \
\
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( *c0 & mask ) << bits2 ) | \
( ( *c1 & mask ) << bits1 ) | \
( ( *c2 & mask ) >> bits0 ) ]; \
\
c0 += STEP; \
c1 += STEP; \
c2 += STEP; \
} \
break; \
} \
case 8: \
{ \
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( *c0 & mask ) << 16 ) | \
( ( *c1 & mask ) << 8 ) | \
( *c2 & mask ) ]; \
\
c0 += STEP; \
c1 += STEP; \
c2 += STEP; \
} \
break; \
} \
} \
}
/***************************************************************/
#define COLOR_CUBE_U8_4_SEARCH( TABLE_TYPE ) \
{ \
const mlib_u8 *c0, *c1, *c2, *c3; \
TABLE_TYPE *table = s->table; \
mlib_s32 bits = s->bits; \
mlib_s32 nbits = 8 - bits; \
mlib_s32 mask = ~( ( 1 << nbits ) - 1 ); \
mlib_s32 j; \
\
c0 = src; \
c1 = src + 1; \
c2 = src + 2; \
c3 = src + 3; \
\
switch( bits ) \
{ \
case 1: \
{ \
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( *c0 & mask ) >> 4 ) | \
( ( *c1 & mask ) >> 5 ) | \
( ( *c2 & mask ) >> 6 ) | \
( ( *c3 & mask ) >> 7 ) ]; \
\
c0 += 4; \
c1 += 4; \
c2 += 4; \
c3 += 4; \
} \
break; \
} \
case 2: \
{ \
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( *c0 & mask ) | \
( ( *c1 & mask ) >> 2 ) | \
( ( *c2 & mask ) >> 4 ) | \
( ( *c3 & mask ) >> 6 ) ]; \
\
c0 += 4; \
c1 += 4; \
c2 += 4; \
c3 += 4; \
} \
break; \
} \
case 3: \
{ \
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( *c0 & mask ) << 4 ) | \
( ( *c1 & mask ) << 1 ) | \
( ( *c2 & mask ) >> 2 ) | \
( ( *c3 & mask ) >> 5 ) ]; \
\
c0 += 4; \
c1 += 4; \
c2 += 4; \
c3 += 4; \
} \
break; \
} \
case 4: \
{ \
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( *c0 & mask ) << 8 ) | \
( ( *c1 & mask ) << 4 ) | \
( *c2 & mask ) | \
( ( *c3 & mask ) >> 4 ) ]; \
\
c0 += 4; \
c1 += 4; \
c2 += 4; \
c3 += 4; \
} \
break; \
} \
case 5: \
case 6: \
{ \
mlib_s32 bits3 = bits * 4 - 8; \
mlib_s32 bits2 = bits3 - bits; \
mlib_s32 bits1 = bits2 - bits; \
mlib_s32 bits0 = 8 - bits; \
\
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( *c0 & mask ) << bits3 ) | \
( ( *c1 & mask ) << bits2 ) | \
( ( *c2 & mask ) << bits1 ) | \
( ( *c3 & mask ) >> bits0 ) ]; \
\
c0 += 4; \
c1 += 4; \
c2 += 4; \
c3 += 4; \
} \
break; \
} \
case 7: \
{ \
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( *c0 & mask ) << 20 ) | \
( ( *c1 & mask ) << 13 ) | \
( ( *c2 & mask ) << 6 ) | \
( ( *c3 & mask ) >> 1 ) ]; \
\
c0 += 4; \
c1 += 4; \
c2 += 4; \
c3 += 4; \
} \
break; \
} \
case 8: /* will never be called */ \
{ \
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( *c0 & mask ) << 24 ) | \
( ( *c1 & mask ) << 16 ) | \
( ( *c2 & mask ) << 8 ) | \
( *c3 & mask ) ]; \
\
c0 += 4; \
c1 += 4; \
c2 += 4; \
c3 += 4; \
} \
break; \
} \
} \
}
/***************************************************************/
#define COLOR_CUBE_S16_3_SEARCH( TABLE_TYPE, SHIFT, STEP ) \
{ \
const mlib_s16 *c0, *c1, *c2; \
mlib_s32 bits = s->bits; \
mlib_s32 nbits = 16 - bits; \
mlib_s32 mask = ~( ( 1 << nbits ) - 1 ); \
TABLE_TYPE *table = s->table; \
mlib_s32 j; \
\
c0 = src + SHIFT; \
c1 = src + 1 + SHIFT; \
c2 = src + 2 + SHIFT; \
\
switch( bits ) \
{ \
case 1: \
case 2: \
case 3: \
case 4: \
case 5: \
{ \
mlib_s32 bits0 = 16 - bits; \
mlib_s32 bits1 = bits0 - bits; \
mlib_s32 bits2 = bits1 - bits; \
\
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( ( *c0 - MLIB_S16_MIN ) & mask ) >> bits2 ) | \
( ( ( *c1 - MLIB_S16_MIN ) & mask ) >> bits1 ) | \
( ( ( *c2 - MLIB_S16_MIN ) & mask ) >> bits0 ) ]; \
\
c0 += STEP; \
c1 += STEP; \
c2 += STEP; \
} \
break; \
} \
case 6: \
case 7: \
{ \
mlib_s32 bits0 = 16 - bits; \
mlib_s32 bits1 = bits0 - bits; \
mlib_s32 bits2 = bits * 3 - 16; \
\
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( ( *c0 - MLIB_S16_MIN ) & mask ) << bits2 ) | \
( ( ( *c1 - MLIB_S16_MIN ) & mask ) >> bits1 ) | \
( ( ( *c2 - MLIB_S16_MIN ) & mask ) >> bits0 ) ]; \
\
c0 += STEP; \
c1 += STEP; \
c2 += STEP; \
} \
break; \
} \
case 8: \
{ \
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( ( *c0 - MLIB_S16_MIN ) & mask ) << 8 ) | \
( ( *c1 - MLIB_S16_MIN ) & mask ) | \
( ( ( *c2 - MLIB_S16_MIN ) & mask ) >> 8 ) ]; \
\
c0 += STEP; \
c1 += STEP; \
c2 += STEP; \
} \
break; \
} \
case 9: \
case 10: \
{ \
mlib_s32 bits0 = 16 - bits; \
mlib_s32 bits1 = 2 * bits - 16; \
mlib_s32 bits2 = bits1 + bits; \
\
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( ( *c0 - MLIB_S16_MIN ) & mask ) << bits2 ) | \
( ( ( *c1 - MLIB_S16_MIN ) & mask ) << bits1 ) | \
( ( ( *c2 - MLIB_S16_MIN ) & mask ) >> bits0 ) ]; \
\
c0 += STEP; \
c1 += STEP; \
c2 += STEP; \
} \
break; \
} \
/* Other cases may not be considered as the table size will be more \
than 2^32 */ \
} \
}
/***************************************************************/
#define COLOR_CUBE_S16_4_SEARCH( TABLE_TYPE ) \
{ \
const mlib_s16 *c0, *c1, *c2, *c3; \
TABLE_TYPE *table = s->table; \
mlib_s32 bits = s->bits; \
mlib_s32 nbits = 16 - bits; \
mlib_s32 mask = ~( ( 1 << nbits ) - 1 ); \
mlib_s32 j; \
\
c0 = src; \
c1 = src + 1; \
c2 = src + 2; \
c3 = src + 3; \
\
switch( bits ) \
{ \
case 1: \
case 2: \
case 3: \
{ \
mlib_s32 bits0 = 16 - bits; \
mlib_s32 bits1 = bits0 - bits; \
mlib_s32 bits2 = bits1 - bits; \
mlib_s32 bits3 = bits2 - bits; \
\
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( ( *c0 - MLIB_S16_MIN ) & mask ) >> bits3 ) | \
( ( ( *c1 - MLIB_S16_MIN ) & mask ) >> bits2 ) | \
( ( ( *c2 - MLIB_S16_MIN ) & mask ) >> bits1 ) | \
( ( ( *c3 - MLIB_S16_MIN ) & mask ) >> bits0 ) ]; \
\
c0 += 4; \
c1 += 4; \
c2 += 4; \
c3 += 4; \
} \
break; \
} \
case 4: \
{ \
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( *c0 - MLIB_S16_MIN ) & mask ) | \
( ( ( *c1 - MLIB_S16_MIN ) & mask ) >> 4 ) | \
( ( ( *c2 - MLIB_S16_MIN ) & mask ) >> 8 ) | \
( ( ( *c3 - MLIB_S16_MIN ) & mask ) >> 12 ) ]; \
\
c0 += 4; \
c1 += 4; \
c2 += 4; \
c3 += 4; \
} \
break; \
} \
case 5: \
{ \
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( ( *c0 - MLIB_S16_MIN ) & mask ) << 4 ) | \
( ( ( *c1 - MLIB_S16_MIN ) & mask ) >> 1 ) | \
( ( ( *c2 - MLIB_S16_MIN ) & mask ) >> 6 ) | \
( ( ( *c3 - MLIB_S16_MIN ) & mask ) >> 11 ) ]; \
\
c0 += 4; \
c1 += 4; \
c2 += 4; \
c3 += 4; \
} \
break; \
} \
case 6: \
case 7: \
{ \
mlib_s32 bits0 = 16 - bits; \
mlib_s32 bits1 = bits0 - bits; \
mlib_s32 bits3 = bits * 4 - 16; \
mlib_s32 bits2 = bits3 - bits; \
\
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( ( *c0 - MLIB_S16_MIN ) & mask ) << bits3 ) | \
( ( ( *c1 - MLIB_S16_MIN ) & mask ) << bits2 ) | \
( ( ( *c2 - MLIB_S16_MIN ) & mask ) >> bits1 ) | \
( ( ( *c3 - MLIB_S16_MIN ) & mask ) >> bits0 ) ]; \
\
c0 += 4; \
c1 += 4; \
c2 += 4; \
c3 += 4; \
} \
break; \
} \
case 8: \
{ \
for( j = 0; j < length; j++ ) \
{ \
dst[ j ] = table[ ( ( ( *c0 - MLIB_S16_MIN ) & mask ) << 16 ) | \
( ( ( *c1 - MLIB_S16_MIN ) & mask ) << 8 ) | \
( ( *c2 - MLIB_S16_MIN ) & mask ) | \
( ( ( *c3 - MLIB_S16_MIN ) & mask ) >> 8 ) ]; \
\
c0 += 4; \
c1 += 4; \
c2 += 4; \
c3 += 4; \
} \
break; \
} \
/* Other cases may not be considered as the table size will be more \
than 2^32 */ \
} \
}
/***************************************************************/
#define BINARY_TREE_SEARCH_RIGHT( POSITION, COLOR_MAX, SHIFT ) \
{ \
if( ( distance >= ( ( ( position[ POSITION ] + current_size - \
c[ POSITION ] ) * ( position[ POSITION ] + current_size - \
c[ POSITION ] ) ) >> SHIFT ) ) && \
( position[ POSITION ] + current_size != COLOR_MAX ) ) \
continue_up = 1; \
}
/***************************************************************/
#define BINARY_TREE_EXPLORE_RIGHT_3( POSITION, COLOR_MAX, IMAGE_TYPE, \
FIRST_NEIBOUR, SECOND_NEIBOUR, SUBSTRACTION, SHIFT ) \
{ \
if( distance >= ( ( ( position[ POSITION ] + current_size - \
c[ POSITION ] ) * ( position[ POSITION ] + \
current_size - c[ POSITION ] ) ) >> SHIFT ) ) \
{ \
if( distance < ( ( ( COLOR_MAX - c[ POSITION ] ) * \
( COLOR_MAX - c[ POSITION ] ) ) >> SHIFT ) ) \
{ \
if( distance < ( ( ( position[ POSITION ] + \
current_size * 2 - c[ POSITION ] ) * \
( position[ POSITION ] + current_size * 2 - \
c[ POSITION ] ) ) >> SHIFT ) ) \
{ \
/* Check only a part of quadrant */ \
mlib_s32 qq = q ^ ( 1 << POSITION ); \
\
check_neibours[ FIRST_NEIBOUR ] += 1; \
check_neibours[ SECOND_NEIBOUR ] += 1; \
check_corner += 1; \
if( node->tag & ( 1 << qq ) ) \
{ \
/* Here is another color cell. \
Check the distance */ \
mlib_s32 new_found_color = \
node->contents.index[ qq ]; \
mlib_u32 newdistance = FIND_DISTANCE_3( c[ 0 ], \
p[ 0 ][ new_found_color ] - SUBSTRACTION, c[ 1 ], \
p[ 1 ][ new_found_color ] - SUBSTRACTION, c[ 2 ], \
p[ 2 ][ new_found_color ] - SUBSTRACTION, SHIFT ); \
\
if( newdistance < distance ) \
{ \
found_color = new_found_color; \
distance = newdistance; \
} \
} \
else if( node->contents.quadrants[ qq ] ) \
/* Only a part of quadrant needs checking */ \
distance = \
mlib_search_quadrant_part_to_left_##IMAGE_TYPE##_3( \
node->contents.quadrants[ qq ], \
distance, &found_color, c, p, \
position[ POSITION ] + current_size, pass - 1, POSITION ); \
} \
else /* Check whole quadrant */ \
{ \
mlib_s32 qq = q ^ ( 1 << POSITION ); \
\
check_neibours[ FIRST_NEIBOUR ] += 2; \
check_neibours[ SECOND_NEIBOUR ] += 2; \
check_corner += 2; \
continue_up = 1; \
if( node->tag & ( 1 << qq ) ) \
{ \
/* Here is another color cell. \
Check the distance */ \
mlib_s32 new_found_color = \
node->contents.index[ qq ]; \
mlib_u32 newdistance = FIND_DISTANCE_3( c[ 0 ], \
p[ 0 ][ new_found_color ] - SUBSTRACTION, c[ 1 ], \
p[ 1 ][ new_found_color ] - SUBSTRACTION, c[ 2 ], \
p[ 2 ][ new_found_color ] - SUBSTRACTION, SHIFT ); \
\
if( newdistance < distance ) \
{ \
found_color = new_found_color; \
distance = newdistance; \
} \
} \
else if( node->contents.quadrants[ qq ] ) \
/* Here is a full node. Just explore it */ \
distance = mlib_search_quadrant_##IMAGE_TYPE##_3( \
node->contents.quadrants[ qq ], \
distance, &found_color, c[ 0 ], c[ 1 ], c[ 2 ], p ); \
} \
} \
else /* Cell is on the edge of the space */ \
{ \
if( position[ POSITION ] + current_size * 2 == \
COLOR_MAX ) \
{ \
/* Check only a part of quadrant */ \
mlib_s32 qq = q ^ ( 1 << POSITION ); \
\
check_neibours[ FIRST_NEIBOUR ] += 1; \
check_neibours[ SECOND_NEIBOUR ] += 1; \
check_corner += 1; \
if( node->tag & ( 1 << qq ) ) \
{ \
/* Here is another color cell. \
Check the distance */ \
mlib_s32 new_found_color = \
node->contents.index[ qq ]; \
mlib_u32 newdistance = FIND_DISTANCE_3( c[ 0 ], \
p[ 0 ][ new_found_color ] - SUBSTRACTION, c[ 1 ], \
p[ 1 ][ new_found_color ] - SUBSTRACTION, c[ 2 ], \
p[ 2 ][ new_found_color ] - SUBSTRACTION, SHIFT ); \
\
if( newdistance < distance ) \
{ \
found_color = new_found_color; \
distance = newdistance; \
} \
} \
else if( node->contents.quadrants[ qq ] ) \
/* Only a part of quadrant needs checking */ \
distance = \
mlib_search_quadrant_part_to_left_##IMAGE_TYPE##_3( \
node->contents.quadrants[ qq ], \
distance, &found_color, c, p, \
position[ POSITION ] + current_size, \
pass - 1, POSITION ); \
} \
else /* Check whole quadrant */ \
{ \
mlib_s32 qq = q ^ ( 1 << POSITION ); \
\
check_neibours[ FIRST_NEIBOUR ] += 2; \
check_neibours[ SECOND_NEIBOUR ] += 2; \
check_corner += 2; \
continue_up = 1; \
if( node->tag & ( 1 << qq ) ) \
{ \
/* Here is another color cell. \
Check the distance */ \
mlib_s32 new_found_color = \
node->contents.index[ qq ]; \
mlib_u32 newdistance = FIND_DISTANCE_3( c[ 0 ], \
p[ 0 ][ new_found_color ] - SUBSTRACTION, c[ 1 ], \
p[ 1 ][ new_found_color ] - SUBSTRACTION, c[ 2 ], \
p[ 2 ][ new_found_color ] - SUBSTRACTION, SHIFT ); \
\
if( newdistance < distance ) \
{ \
found_color = new_found_color; \
distance = newdistance; \
} \
} \
else if( node->contents.quadrants[ qq ] ) \
/* Here is a full node. Just explore it */ \
distance = mlib_search_quadrant_##IMAGE_TYPE##_3( \
node->contents.quadrants[ qq ], \
distance, &found_color, c[ 0 ], c[ 1 ], c[ 2 ], p ); \
} \
} \
} \
}
/***************************************************************/
#define BINARY_TREE_EXPLORE_RIGHT_4( POSITION, COLOR_MAX, IMAGE_TYPE, \
FIRST_NEIBOUR, SECOND_NEIBOUR, THIRD_NEIBOUR, SUBSTRACTION, SHIFT ) \
{ \
if( distance >= ( ( ( position[ POSITION ] + current_size - \
c[ POSITION ] ) * ( position[ POSITION ] + \
current_size - c[ POSITION ] ) ) >> SHIFT ) ) \
{ \
if( distance < ( ( ( COLOR_MAX - c[ POSITION ] ) * \
( COLOR_MAX - c[ POSITION ] ) ) >> SHIFT ) ) \
{ \
if( distance < ( ( ( position[ POSITION ] + \
current_size * 2 - c[ POSITION ] ) * \
( position[ POSITION ] + current_size * 2 - \
c[ POSITION ] ) ) >> SHIFT ) ) \
{ \
/* Check only a part of quadrant */ \
mlib_s32 qq = q ^ ( 1 << POSITION ); \
\
check_neibours[ FIRST_NEIBOUR ] += 1; \
check_neibours[ SECOND_NEIBOUR ] += 1; \
check_neibours[ THIRD_NEIBOUR ] += 1; \
if( node->tag & ( 1 << qq ) ) \
{ \
/* Here is another color cell. \
Check the distance */ \
mlib_s32 new_found_color = \
node->contents.index[ qq ]; \
mlib_u32 newdistance = FIND_DISTANCE_4( c[ 0 ], \
p[ 0 ][ new_found_color ] - SUBSTRACTION, c[ 1 ], \
p[ 1 ][ new_found_color ] - SUBSTRACTION, c[ 2 ], \
p[ 2 ][ new_found_color ] - SUBSTRACTION, c[ 3 ], \
p[ 3 ][ new_found_color ] - SUBSTRACTION, SHIFT ); \
\
if( newdistance < distance ) \
{ \
found_color = new_found_color; \
distance = newdistance; \
} \
} \
else if( node->contents.quadrants[ qq ] ) \
/* Only a part of quadrant needs checking */ \
distance = \
mlib_search_quadrant_part_to_left_##IMAGE_TYPE##_4( \
node->contents.quadrants[ qq ], \
distance, &found_color, c, p, \
position[ POSITION ] + current_size, pass - 1, POSITION ); \
} \
else /* Check whole quadrant */ \
{ \
mlib_s32 qq = q ^ ( 1 << POSITION ); \
\
check_neibours[ FIRST_NEIBOUR ] += 2; \
check_neibours[ SECOND_NEIBOUR ] += 2; \
check_neibours[ THIRD_NEIBOUR ] += 2; \
continue_up = 1; \
if( node->tag & ( 1 << qq ) ) \
{ \
/* Here is another color cell. \
Check the distance */ \
mlib_s32 new_found_color = \
node->contents.index[ qq ]; \
mlib_u32 newdistance = FIND_DISTANCE_4( c[ 0 ], \
p[ 0 ][ new_found_color ] - SUBSTRACTION, c[ 1 ], \
p[ 1 ][ new_found_color ] - SUBSTRACTION, c[ 2 ], \
p[ 2 ][ new_found_color ] - SUBSTRACTION, c[ 3 ], \
p[ 3 ][ new_found_color ] - SUBSTRACTION, SHIFT ); \
\
if( newdistance < distance ) \
{ \
found_color = new_found_color; \
distance = newdistance; \
} \
} \
else if( node->contents.quadrants[ qq ] ) \
/* Here is a full node. Just explore it */ \
distance = mlib_search_quadrant_##IMAGE_TYPE##_4( \
node->contents.quadrants[ qq ], \
distance, &found_color, c[ 0 ], c[ 1 ], c[ 2 ], c[ 3 ], p ); \
} \
} \
else /* Cell is on the edge of the space */ \
{ \
if( position[ POSITION ] + current_size * 2 == \
COLOR_MAX ) \
{ \
/* Check only a part of quadrant */ \
mlib_s32 qq = q ^ ( 1 << POSITION ); \
\
check_neibours[ FIRST_NEIBOUR ] += 1; \
check_neibours[ SECOND_NEIBOUR ] += 1; \
check_neibours[ THIRD_NEIBOUR ] += 1; \
if( node->tag & ( 1 << qq ) ) \
{ \
/* Here is another color cell. \
Check the distance */ \
mlib_s32 new_found_color = \
node->contents.index[ qq ]; \
mlib_u32 newdistance = FIND_DISTANCE_4( c[ 0 ], \
p[ 0 ][ new_found_color ] - SUBSTRACTION, c[ 1 ], \
p[ 1 ][ new_found_color ] - SUBSTRACTION, c[ 2 ], \
p[ 2 ][ new_found_color ] - SUBSTRACTION, c[ 3 ], \
p[ 3 ][ new_found_color ] - SUBSTRACTION, SHIFT ); \
\
if( newdistance < distance ) \
{ \
found_color = new_found_color; \
distance = newdistance; \
} \
} \
else if( node->contents.quadrants[ qq ] ) \
/* Only a part of quadrant needs checking */ \
distance = \
mlib_search_quadrant_part_to_left_##IMAGE_TYPE##_4( \
node->contents.quadrants[ qq ], \
distance, &found_color, c, p, \
position[ POSITION ] + current_size, \
pass - 1, POSITION ); \
} \
else /* Check whole quadrant */ \
{ \
mlib_s32 qq = q ^ ( 1 << POSITION ); \
\
check_neibours[ FIRST_NEIBOUR ] += 2; \
check_neibours[ SECOND_NEIBOUR ] += 2; \
check_neibours[ THIRD_NEIBOUR ] += 2; \
continue_up = 1; \
if( node->tag & ( 1 << qq ) ) \
{ \
/* Here is another color cell. \
Check the distance */ \
mlib_s32 new_found_color = \
node->contents.index[ qq ]; \
mlib_u32 newdistance = FIND_DISTANCE_4( c[ 0 ], \
p[ 0 ][ new_found_color ] - SUBSTRACTION, c[ 1 ], \
p[ 1 ][ new_found_color ] - SUBSTRACTION, c[ 2 ], \
p[ 2 ][ new_found_color ] - SUBSTRACTION, c[ 3 ], \
p[ 3 ][ new_found_color ] - SUBSTRACTION, SHIFT ); \
\
if( newdistance < distance ) \
{ \
found_color = new_found_color; \
distance = newdistance; \
} \
} \
else if( node->contents.quadrants[ qq ] ) \
/* Here is a full node. Just explore it */ \
distance = mlib_search_quadrant_##IMAGE_TYPE##_4( \
node->contents.quadrants[ qq ], \
distance, &found_color, c[ 0 ], c[ 1 ], c[ 2 ], c[ 3 ], p ); \
} \
} \
} \
}
/***************************************************************/
#define BINARY_TREE_SEARCH_LEFT( POSITION, SHIFT ) \
{ \
if( ( distance > ( ( ( position[ POSITION ] - c[ POSITION ] ) * \
( position[ POSITION ] - c[ POSITION ] ) ) >> SHIFT ) ) && \
position[ POSITION ] ) \
continue_up = 1; \
}
/***************************************************************/
#define BINARY_TREE_EXPLORE_LEFT_3( POSITION, IMAGE_TYPE, \
FIRST_NEIBOUR, SECOND_NEIBOUR, SUBSTRACTION, SHIFT ) \
{ \
if( distance > \
( ( ( c[ POSITION ] - position[ POSITION ] ) * \
( c[ POSITION ] - position[ POSITION ] ) ) >> SHIFT ) ) \
{ \
if( distance <= ( ( c[ POSITION ] * c[ POSITION ] ) >> SHIFT ) ) \
{ \
if( distance <= ( ( ( c[ POSITION ] + current_size - \
position[ POSITION ] ) * \
( c[ POSITION ] + current_size - \
position[ POSITION ] ) ) >> SHIFT ) ) \
{ \
mlib_s32 qq = q ^ ( 1 << POSITION ); \
\
check_neibours[ FIRST_NEIBOUR ] += 1; \
check_neibours[ SECOND_NEIBOUR ] += 1; \
check_corner += 1; \
if( node->tag & ( 1 << qq ) ) \
{ \
/* Here is another color cell. \
Check the distance */ \
mlib_s32 new_found_color = \
node->contents.index[ qq ]; \
mlib_u32 newdistance = FIND_DISTANCE_3( c[ 0 ], \
p[ 0 ][ new_found_color ] - SUBSTRACTION, c[ 1 ], \
p[ 1 ][ new_found_color ] - SUBSTRACTION, c[ 2 ], \
p[ 2 ][ new_found_color ] - SUBSTRACTION, SHIFT ); \
\
if( newdistance < distance ) \
{ \
found_color = new_found_color; \
distance = newdistance; \
} \
} \
else if( node->contents.quadrants[ qq ] ) \
/* Only a part of quadrant needs checking */ \
distance = \
mlib_search_quadrant_part_to_right_##IMAGE_TYPE##_3( \
node->contents.quadrants[ qq ], \
distance, &found_color, c, p, \
position[ POSITION ] - current_size, pass - 1, POSITION ); \
} \
else /* Check whole quadrant */ \
{ \
mlib_s32 qq = q ^ ( 1 << POSITION ); \
\
check_neibours[ FIRST_NEIBOUR ] += 2; \
check_neibours[ SECOND_NEIBOUR ] += 2; \
check_corner += 2; \
continue_up = 1; \
if( node->tag & ( 1 << qq ) ) \
{ \
/* Here is another color cell. \
Check the distance */ \
mlib_s32 new_found_color = \
node->contents.index[ qq ]; \
mlib_u32 newdistance = FIND_DISTANCE_3( c[ 0 ], \
p[ 0 ][ new_found_color ] - SUBSTRACTION, c[ 1 ], \
p[ 1 ][ new_found_color ] - SUBSTRACTION, c[ 2 ], \
p[ 2 ][ new_found_color ] - SUBSTRACTION, SHIFT ); \
\
if( newdistance < distance ) \
{ \
found_color = new_found_color; \
distance = newdistance; \
} \
} \
else if( node->contents.quadrants[ qq ] ) \
/* Here is a full node. Just explore it */ \
distance = mlib_search_quadrant_##IMAGE_TYPE##_3( \
node->contents.quadrants[ qq ], \
distance, &found_color, c[ 0 ], c[ 1 ], c[ 2 ], p ); \
} \
} \
else \
{ \
if( !( position[ POSITION ] - current_size ) ) \
{ \
mlib_s32 qq = q ^ ( 1 << POSITION ); \
\
check_neibours[ FIRST_NEIBOUR ] += 1; \
check_neibours[ SECOND_NEIBOUR ] += 1; \
check_corner += 1; \
if( node->tag & ( 1 << qq ) ) \
{ \
/* Here is another color cell. \
Check the distance */ \
mlib_s32 new_found_color = \
node->contents.index[ qq ]; \
mlib_u32 newdistance = FIND_DISTANCE_3( c[ 0 ], \
p[ 0 ][ new_found_color ] - SUBSTRACTION, c[ 1 ], \
p[ 1 ][ new_found_color ] - SUBSTRACTION, c[ 2 ], \
p[ 2 ][ new_found_color ] - SUBSTRACTION, SHIFT ); \
\
if( newdistance < distance ) \
{ \
found_color = new_found_color; \
distance = newdistance; \
} \
} \
else if( node->contents.quadrants[ qq ] ) \
/* Only a part of quadrant needs checking */ \
distance = \
mlib_search_quadrant_part_to_right_##IMAGE_TYPE##_3( \
node->contents.quadrants[ qq ], \
distance, &found_color, c, p, \
position[ POSITION ] - current_size, pass - 1, POSITION ); \
} \
else \
{ \
mlib_s32 qq = q ^ ( 1 << POSITION ); \
\
check_neibours[ FIRST_NEIBOUR ] += 2; \
check_neibours[ SECOND_NEIBOUR ] += 2; \
check_corner += 2; \
continue_up = 1; \
if( node->tag & ( 1 << qq ) ) \
{ \
/* Here is another color cell. \
Check the distance */ \
mlib_s32 new_found_color = \
node->contents.index[ qq ]; \
mlib_u32 newdistance = FIND_DISTANCE_3( c[ 0 ], \
p[ 0 ][ new_found_color ] - SUBSTRACTION, c[ 1 ], \
p[ 1 ][ new_found_color ] - SUBSTRACTION, c[ 2 ], \
p[ 2 ][ new_found_color ] - SUBSTRACTION, SHIFT ); \
\
if( newdistance < distance ) \
{ \
found_color = new_found_color; \
distance = newdistance; \
} \
} \
else if( node->contents.quadrants[ qq ] ) \
/* Here is a full node. Just explore it */ \
distance = mlib_search_quadrant_##IMAGE_TYPE##_3( \
node->contents.quadrants[ qq ], \
distance, &found_color, c[ 0 ], c[ 1 ], c[ 2 ], p ); \
} \
} \
} \
}
/***************************************************************/
#define BINARY_TREE_EXPLORE_LEFT_4( POSITION, IMAGE_TYPE, \
FIRST_NEIBOUR, SECOND_NEIBOUR, THIRD_NEIBOUR, SUBSTRACTION, SHIFT ) \
{ \
if( distance > \
( ( ( c[ POSITION ] - position[ POSITION ] ) * \
( c[ POSITION ] - position[ POSITION ] ) ) >> SHIFT ) ) \
{ \
if( distance <= ( ( c[ POSITION ] * c[ POSITION ] ) >> SHIFT ) ) \
{ \
if( distance <= ( ( ( c[ POSITION ] + current_size - \
position[ POSITION ] ) * \
( c[ POSITION ] + current_size - \
position[ POSITION ] ) ) >> SHIFT ) ) \
{ \
mlib_s32 qq = q ^ ( 1 << POSITION ); \
\
check_neibours[ FIRST_NEIBOUR ] += 1; \
check_neibours[ SECOND_NEIBOUR ] += 1; \
check_neibours[ THIRD_NEIBOUR ] += 1; \
if( node->tag & ( 1 << qq ) ) \
{ \
/* Here is another color cell. \
Check the distance */ \
mlib_s32 new_found_color = \
node->contents.index[ qq ]; \
mlib_u32 newdistance = FIND_DISTANCE_4( c[ 0 ], \
p[ 0 ][ new_found_color ] - SUBSTRACTION, c[ 1 ], \
p[ 1 ][ new_found_color ] - SUBSTRACTION, c[ 2 ], \
p[ 2 ][ new_found_color ] - SUBSTRACTION, c[ 3 ], \
p[ 3 ][ new_found_color ] - SUBSTRACTION, SHIFT ); \
\
if( newdistance < distance ) \
{ \
found_color = new_found_color; \
distance = newdistance; \
} \
} \
else if( node->contents.quadrants[ qq ] ) \
/* Only a part of quadrant needs checking */ \
distance = \
mlib_search_quadrant_part_to_right_##IMAGE_TYPE##_4( \
node->contents.quadrants[ qq ], \
distance, &found_color, c, p, \
position[ POSITION ] - current_size, pass - 1, POSITION ); \
} \
else /* Check whole quadrant */ \
{ \
mlib_s32 qq = q ^ ( 1 << POSITION ); \
\
check_neibours[ FIRST_NEIBOUR ] += 2; \
check_neibours[ SECOND_NEIBOUR ] += 2; \
check_neibours[ THIRD_NEIBOUR ] += 2; \
continue_up = 1; \
if( node->tag & ( 1 << qq ) ) \
{ \
/* Here is another color cell. \
Check the distance */ \
mlib_s32 new_found_color = \
node->contents.index[ qq ]; \
mlib_u32 newdistance = FIND_DISTANCE_4( c[ 0 ], \
p[ 0 ][ new_found_color ] - SUBSTRACTION, c[ 1 ], \
p[ 1 ][ new_found_color ] - SUBSTRACTION, c[ 2 ], \
p[ 2 ][ new_found_color ] - SUBSTRACTION, c[ 3 ], \
p[ 3 ][ new_found_color ] - SUBSTRACTION, SHIFT ); \
\
if( newdistance < distance ) \
{ \
found_color = new_found_color; \
distance = newdistance; \
} \
} \
else if( node->contents.quadrants[ qq ] ) \
/* Here is a full node. Just explore it */ \
distance = mlib_search_quadrant_##IMAGE_TYPE##_4( \
node->contents.quadrants[ qq ], \
distance, &found_color, c[ 0 ], c[ 1 ], c[ 2 ], c[ 3 ], p ); \
} \
} \
else \
{ \
if( !( position[ POSITION ] - current_size ) ) \
{ \
mlib_s32 qq = q ^ ( 1 << POSITION ); \
\
check_neibours[ FIRST_NEIBOUR ] += 1; \
check_neibours[ SECOND_NEIBOUR ] += 1; \
check_neibours[ THIRD_NEIBOUR ] += 1; \
if( node->tag & ( 1 << qq ) ) \
{ \
/* Here is another color cell. \
Check the distance */ \
mlib_s32 new_found_color = \
node->contents.index[ qq ]; \
mlib_u32 newdistance = FIND_DISTANCE_4( c[ 0 ], \
p[ 0 ][ new_found_color ] - SUBSTRACTION, c[ 1 ], \
p[ 1 ][ new_found_color ] - SUBSTRACTION, c[ 2 ], \
p[ 2 ][ new_found_color ] - SUBSTRACTION, c[ 3 ], \
p[ 3 ][ new_found_color ] - SUBSTRACTION, SHIFT ); \
\
if( newdistance < distance ) \
{ \
found_color = new_found_color; \
distance = newdistance; \
} \
} \
else if( node->contents.quadrants[ qq ] ) \
/* Only a part of quadrant needs checking */ \
distance = \
mlib_search_quadrant_part_to_right_##IMAGE_TYPE##_4( \
node->contents.quadrants[ qq ], \
distance, &found_color, c, p, \
position[ POSITION ] - current_size, pass - 1, POSITION ); \
} \
else \
{ \
mlib_s32 qq = q ^ ( 1 << POSITION ); \
\
check_neibours[ FIRST_NEIBOUR ] += 2; \
check_neibours[ SECOND_NEIBOUR ] += 2; \
check_neibours[ THIRD_NEIBOUR ] += 2; \
continue_up = 1; \
if( node->tag & ( 1 << qq ) ) \
{ \
/* Here is another color cell. \
Check the distance */ \
mlib_s32 new_found_color = \
node->contents.index[ qq ]; \
mlib_u32 newdistance = FIND_DISTANCE_4( c[ 0 ], \
p[ 0 ][ new_found_color ] - SUBSTRACTION, c[ 1 ], \
p[ 1 ][ new_found_color ] - SUBSTRACTION, c[ 2 ], \
p[ 2 ][ new_found_color ] - SUBSTRACTION, c[ 3 ], \
p[ 3 ][ new_found_color ] - SUBSTRACTION, SHIFT ); \
\
if( newdistance < distance ) \
{ \
found_color = new_found_color; \
distance = newdistance; \
} \
} \
else if( node->contents.quadrants[ qq ] ) \
/* Here is a full node. Just explore it */ \
distance = mlib_search_quadrant_##IMAGE_TYPE##_4( \
node->contents.quadrants[ qq ], \
distance, &found_color, c[ 0 ], c[ 1 ], c[ 2 ], c[ 3 ], p ); \
} \
} \
} \
}
/***************************************************************/
#define CHECK_QUADRANT_U8_3( qq ) \
{ \
if( node->tag & ( 1 << qq ) ) \
{ \
/* Here is another color cell. Check the distance */ \
mlib_s32 new_found_color = node->contents.index[ qq ]; \
mlib_u32 newdistance = FIND_DISTANCE_3( c[ 0 ], \
p[ 0 ][ new_found_color ], c[ 1 ], \
p[ 1 ][ new_found_color ], c[ 2 ], \
p[ 2 ][ new_found_color ], 0 ); \
\
if( newdistance < distance ) \
{ \
found_color = new_found_color; \
distance = newdistance; \
} \
} \
else if( node->contents.quadrants[ qq ] ) \
/* Here is a full node. Just explore it all */ \
distance = mlib_search_quadrant_U8_3( \
node->contents.quadrants[ qq ], distance, &found_color, \
c[ 0 ], c[ 1 ], c[ 2 ], p ); \
/* Else there is just an empty cell */ \
}
/***************************************************************/
#define CHECK_QUADRANT_S16_3( qq ) \
{ \
if( node->tag & ( 1 << qq ) ) \
{ \
/* Here is another color cell. Check the distance */ \
mlib_s32 new_found_color = node->contents.index[ qq ]; \
mlib_u32 palc0, palc1, palc2, newdistance; \
\
palc0 = p[ 0 ][ new_found_color ] - MLIB_S16_MIN; \
palc1 = p[ 1 ][ new_found_color ] - MLIB_S16_MIN; \
palc2 = p[ 2 ][ new_found_color ] - MLIB_S16_MIN; \
\
newdistance = FIND_DISTANCE_3( c[ 0 ], palc0, \
c[ 1 ], palc1, \
c[ 2 ], palc2, 2 ); \
\
if( newdistance < distance ) \
{ \
found_color = new_found_color; \
distance = newdistance; \
} \
} \
else if( node->contents.quadrants[ qq ] ) \
/* Here is a full node. Just explore it all */ \
distance = mlib_search_quadrant_S16_3( \
node->contents.quadrants[ qq ], distance, &found_color, \
c[ 0 ], c[ 1 ], c[ 2 ], p ); \
/* Else there is just an empty cell */ \
}
/***************************************************************/
#define BINARY_TREE_SEARCH_3( SOURCE_IMAGE, POINTER_TYPE, BITS, \
COLOR_MAX, SUBTRACTION, POINTER_SHIFT, STEP, SHIFT ) \
{ \
const POINTER_TYPE *channels[ 3 ], *p[ 3 ]; \
mlib_u32 c[ 3 ]; \
mlib_s32 j; \
\
p[ 0 ] = s->lut[ 0 ]; \
p[ 1 ] = s->lut[ 1 ]; \
p[ 2 ] = s->lut[ 2 ]; \
channels[ 0 ] = src + POINTER_SHIFT; \
channels[ 1 ] = src + 1 + POINTER_SHIFT; \
channels[ 2 ] = src + 2 + POINTER_SHIFT; \
\
for( j = 0; j < length; j++ ) \
{ \
mlib_s32 pass = BITS - 1; \
mlib_u32 position[ 3 ] = { 0, 0, 0 }; \
mlib_s32 we_found_it = 0; \
struct lut_node_3 *node = s->table; \
/* Stack pointer pointers to the first free element of stack. */ \
/* The node we are in is in the `node' */ \
struct \
{ \
struct lut_node_3 *node; \
mlib_s32 q; \
} stack[ BITS ]; \
mlib_s32 stack_pointer = 0; \
\
c[ 0 ] = *channels[ 0 ] - SUBTRACTION; \
c[ 1 ] = *channels[ 1 ] - SUBTRACTION; \
c[ 2 ] = *channels[ 2 ] - SUBTRACTION; \
\
do \
{ \
mlib_s32 q; \
mlib_u32 current_size = 1 << pass; \
\
q = ( ( c[ 0 ] >> pass ) & 1 ) | \
( ( ( c[ 1 ] << 1 ) >> pass ) & 2 ) | \
( ( ( c[ 2 ] << 2 ) >> pass ) & 4 ); \
\
position[ 0 ] |= c[ 0 ] & current_size; \
position[ 1 ] |= c[ 1 ] & current_size; \
position[ 2 ] |= c[ 2 ] & current_size; \
\
if( node->tag & ( 1 << q ) ) \
{ \
/* \
Here is a cell with one color. We need to be sure it's \
the one that is the closest to our color \
*/ \
mlib_s32 palindex = node->contents.index[ q ]; \
mlib_u32 palc[ 3 ]; \
mlib_s32 identical; \
\
palc[ 0 ] = p[ 0 ][ palindex ] - SUBTRACTION; \
palc[ 1 ] = p[ 1 ][ palindex ] - SUBTRACTION; \
palc[ 2 ] = p[ 2 ][ palindex ] - SUBTRACTION; \
\
identical = ( palc[ 0 ] - c[ 0 ] ) | ( palc[ 1 ] - c[ 1 ] ) | \
( palc[ 2 ] - c[ 2 ] ); \
\
if( !identical || BITS - pass == bits ) \
{ \
/* Oh, here it is :) */ \
dst[ j ] = palindex + s->offset; \
we_found_it = 1; \
} \
else \
{ \
mlib_u32 distance; \
/* First index is the channel, second is the number of the \
side */ \
mlib_s32 found_color; \
mlib_s32 continue_up; \
\
distance = FIND_DISTANCE_3( c[ 0 ], palc[ 0 ], \
c[ 1 ], palc[ 1 ], c[ 2 ], palc[ 2 ], SHIFT ); \
found_color = palindex; \
\
do \
{ \
mlib_s32 check_corner; \
\
/* \
Neibours are enumerated in a cicle: \
0 - between quadrants 0 and 1, \
1 - between quadrants 1 and 2 and \
2 - between quadrants 2 and 0 \
*/ \
mlib_s32 check_neibours[ 3 ]; \
\
/* \
Others are three two neibour quadrants \
\
Side number is [ <number of the coordinate >][
Other Java examples (source code examples)Here is a short list of links related to this Java mlib_ImageColorTrue2Index.c source code file: |
The search page
Other Java source code examples at this package level
Click here to learn more about this project
