mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-12-04 16:59:12 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
dc1eb583b4
opencv/modules/legacy/src/enmin.cpp
OpenCV Buildbot 04384a71e4 Normalize line endings and whitespace
2012-10-17 15:32:23 +04:00

1382 lines
50 KiB
C++
Raw Blame History

/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// Intel License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of Intel Corporation may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "precomp.hpp"
#if 0
//#include "windows.h"
//#define ALPHA_EXPANSION
#ifndef ALPHA_EXPANSION
#define ALPHA_BETA_EXCHANGE
#endif
#define MAX_LABEL 20
#define CV_MODULE(xxx) \
( (xxx) < 0 ? -(xxx) : (xxx) )
#define CV_MAX3(xxx1,xxx2,xxx3) \
( (xxx1) > (xxx2) && (xxx1) > (xxx3) ? (xxx1) : \
(xxx2) > (xxx3) ? (xxx2) : (xxx3) )
#define CV_MIN2(xxx1,xxx2) \
( (xxx1) < (xxx2) ? (xxx1) : (xxx2) )
#define getSizeForGraph(xxxType) \
( sizeof(xxxType) < 8 ? 8 : sizeof(xxxType) + 4 - sizeof(xxxType) % 4 )
#define INT_INFINITY 1000000000
#define MAX_DIFFERENCE 10
// struct Vertex is used for storing vertices of graph
// coord - coordinate corresponding pixel on the real image line
struct Vertex
{
CvGraphVtx vtx;
int coord;
};
// struct Edge is used for storing edges of graph
// weight - weight of the edge ( maximum flow via the edge )
// flow - current flow via the edge
// srcVtx - coordinate of source vertex on the real image line
// destVtx - coordinate of destination vertex on the real image line
struct Edge
{
CV_GRAPH_EDGE_FIELDS()
int weight;
int flow;
int srcVtx;
int destVtx;
};
// function vFunc is energy function which determines the difference
// between two labels ( alpha and beta )
// alpha - label number one
// beta - label number two
inline int vFunc( int alpha, int beta )
{
if( alpha == beta )
return 0;
else
return /*1*//*5*/10;
}
// function dFunc is energy function which determines energy of interaction
// between pixel ( having coordinate xCoord ) and label
// leftLine - line of left image
// rightLine - line of right image
// xCoord - coordinate of pixel on the left image
// label - label corresponding to the pixel
// width - width of the image line in pixels
inline int dFunc( unsigned char* leftLine,
unsigned char* rightLine,
int xCoord,
int label,
int width)
{
assert( xCoord >= 0 && xCoord < width );
int r, g, b;
int yCoord = xCoord + label;
if( yCoord >= width )
yCoord = width;
if( yCoord < 0 )
yCoord = 0;
r = leftLine[ 3 * xCoord ] - rightLine[ 3 * yCoord ];
g = leftLine[ 3 * xCoord + 1 ] - rightLine[ 3 * yCoord + 1 ];
b = leftLine[ 3 * xCoord + 2 ] - rightLine[ 3 * yCoord + 2 ];
r = CV_MODULE( r );
g = CV_MODULE( g );
b = CV_MODULE( b );
return CV_MAX3( r, g, b );
}
// function allocTempMem allocates all temporary memory needed for work
// of some function
// memPtr - pointer to pointer to the large block of memory
// verticesPtr - pointer to pointer to block of memory for
// temporary storing vertices
// width - width of line in pixels
void allocTempMem( int** memPtr,
int** verticesPtr,
int width )
{
int* tempPtr = ( int* ) malloc( ( width + 2 ) * 7 * sizeof( int ) );
*verticesPtr = tempPtr;
*memPtr = *verticesPtr + width + 2;
}
// function freeTempMem frees all allocated by allocTempMem function memory
// memPtr - pointer to pointer to the large block of memory
// verticesPtr - pointer to pointer to block of memory for
// temporary storing vertices
void freeTempMem( int** memPtr,
int** verticesPtr )
{
free( ( void* )( *verticesPtr ) );
*verticesPtr = NULL;
*memPtr = NULL;
}
// function makeGraph creates initial graph to find maximum flow in it
// graphPtr - pointer to pointer to CvGraph structure to be filled
// leftLine - pointer to the left image line
// rightLine - pointer to the right image line
// alpha - label number one for doing exchange
// beta - label number two for doing exchange
// corr - pointer to array of correspondences ( each element
// of array includes disparity of pixel on right image
// for pixel each on left image ). This pointer direct
// to correspondence ofr one line only
// width - width of image lines in pixels
// storage - pointer to CvMemStorage structure which contains
// memory storage
void makeGraph( CvGraph** graphPtr,
unsigned char* leftLine,
unsigned char* rightLine,
int alpha,
int beta,
int* corr,
int width,
CvMemStorage* storage )
{
int i;
if( *graphPtr ) {
cvClearGraph( *graphPtr );
}
/*else {*/
*graphPtr = cvCreateGraph( CV_SEQ_KIND_GRAPH | CV_GRAPH_FLAG_ORIENTED,
sizeof( CvGraph ),
getSizeForGraph( Vertex ),
getSizeForGraph( Edge ),
storage );
/*}*/
CvGraph* graph = *graphPtr;
#ifdef ALPHA_BETA_EXCHANGE
CvGraphVtx* newVtxPtr;
for( i = 0; i < width; i ++ )
{
if( corr[i] == alpha || corr[i] == beta ) {
cvGraphAddVtx( graph, NULL, &newVtxPtr );
( ( Vertex* )newVtxPtr ) -> coord = i;
}
} /* for( i = 0; i < width; i ++ ) */
cvGraphAddVtx( graph, NULL, &newVtxPtr );
if( newVtxPtr )
( ( Vertex* )newVtxPtr ) -> coord = -2; /* adding alpha vertex */
cvGraphAddVtx( graph, NULL, &newVtxPtr );
if( newVtxPtr )
( ( Vertex* )newVtxPtr ) -> coord = -1; /* adding beta vertex */
int alphaVtx = graph -> total - 2;
int betaVtx = graph -> total - 1;
CvGraphEdge* newEdgePtr;
CvGraphVtx* vtxPtr;
if( graph -> total > 2 )
{
for( i = 0; i < alphaVtx; i ++ )
{
vtxPtr = cvGetGraphVtx( graph, i );
/* adding edge oriented from alpha vertex to current vertex */
cvGraphAddEdge( graph, alphaVtx, i, NULL, &newEdgePtr );
( ( Edge* )newEdgePtr ) -> weight = dFunc( leftLine,
rightLine,
( ( Vertex* )vtxPtr ) -> coord,
alpha,
width );
( ( Edge* )newEdgePtr ) -> flow = 0;
if( i != 0 ) {
CvGraphVtx* tempVtxPtr = cvGetGraphVtx( graph, i - 1 );
/* if vertices are neighbours */
if( ( ( Vertex* )tempVtxPtr ) -> coord + 1 ==
( ( Vertex* )vtxPtr ) -> coord )
{
( ( Edge* )newEdgePtr ) -> weight +=
vFunc( corr[ ( ( Vertex* )tempVtxPtr ) -> coord ],
alpha );
/* adding neighbour edge oriented from current vertex
to the previous one */
CvGraphEdge* tempEdgePtr;
cvGraphAddEdge( graph, i, i - 1, NULL, &tempEdgePtr );
( ( Edge* )tempEdgePtr ) -> weight = vFunc( alpha, beta );
( ( Edge* )tempEdgePtr ) -> flow = 0;
( ( Edge* )tempEdgePtr ) -> srcVtx =
( ( Vertex* )vtxPtr ) -> coord;
( ( Edge* )tempEdgePtr ) -> destVtx =
( ( Vertex* )tempVtxPtr ) -> coord;
}
} /* if( i != 0 ) */
if( i != alphaVtx - 1 ) {
CvGraphVtx* tempVtxPtr = cvGetGraphVtx( graph, i + 1 );
/* if vertices are neighbours */
if( ( ( Vertex* )tempVtxPtr ) -> coord - 1 ==
( ( Vertex* )vtxPtr ) -> coord )
{
( ( Edge* )newEdgePtr ) -> weight +=
vFunc( corr[ ( ( Vertex* )tempVtxPtr ) -> coord ],
alpha );
/* adding neighbour edge oriented from current vertex
to the next one */
CvGraphEdge* tempEdgePtr;
cvGraphAddEdge( graph, i, i + 1, NULL, &tempEdgePtr );
( ( Edge* )tempEdgePtr ) -> weight = vFunc( alpha, beta );
( ( Edge* )tempEdgePtr ) -> flow = 0;
( ( Edge* )tempEdgePtr ) -> srcVtx =
( ( Vertex* )vtxPtr ) -> coord;
( ( Edge* )tempEdgePtr ) -> destVtx =
( ( Vertex* )tempVtxPtr ) -> coord;
}
} /* if( i != alphaVtx - 1 ) */
( ( Edge* )newEdgePtr ) -> flow = 0;
( ( Edge* )newEdgePtr ) -> srcVtx = -1; /* source vertex is alpha
vertex */
( ( Edge* )newEdgePtr ) -> destVtx = ( ( Vertex* )vtxPtr ) -> coord;
/* adding edge oriented from current vertex to beta vertex */
cvGraphAddEdge( graph, i, betaVtx, NULL, &newEdgePtr );
( ( Edge* )newEdgePtr ) -> weight = dFunc( leftLine,
rightLine,
( ( Vertex* )vtxPtr ) -> coord,
beta,
width );
( ( Edge* )newEdgePtr ) -> flow = 0;
if( i != 0 ) {
CvGraphVtx* tempVtxPtr = cvGetGraphVtx( graph, i - 1 );
/* if vertices are neighbours */
if( ( ( Vertex* )tempVtxPtr ) -> coord + 1 ==
( ( Vertex* )vtxPtr ) -> coord )
{
( ( Edge* )newEdgePtr ) -> weight +=
vFunc( corr[ ( ( Vertex* )tempVtxPtr ) -> coord ],
beta );
}
} /* if( i != 0 ) */
if( i != alphaVtx - 1 ) {
CvGraphVtx* tempVtxPtr = cvGetGraphVtx( graph, i + 1 );
/* if vertices are neighbours */
if( ( ( Vertex* )tempVtxPtr ) -> coord - 1 ==
( ( Vertex* )vtxPtr ) -> coord )
{
( ( Edge* )newEdgePtr ) -> weight +=
vFunc( corr[ ( ( Vertex* )tempVtxPtr ) -> coord ],
beta );
}
} /* if( i != alphaVtx - 1 ) */
( ( Edge* )newEdgePtr ) -> flow = 0;
( ( Edge* )newEdgePtr ) -> srcVtx =
( ( Vertex* )vtxPtr ) -> coord;
( ( Edge* )newEdgePtr ) -> destVtx = -2; /* destination vertex is
beta vertex */
} /* for( i = 0; i < graph -> total - 2; i ++ ) */
} /* if( graph -> total > 2 ) */
#endif /* #ifdef ALPHA_BETA_EXCHANGE */
#ifdef ALPHA_EXPANSION
#endif /* #ifdef ALPHA_EXPANSION */
} /* makeGraph */
// function makeHelpGraph creates help graph using initial graph
// graph - pointer to initial graph ( represented by CvGraph
// structure )
// hlpGraphPtr - pointer to pointer to new help graph
// storage - pointer to CvStorage structure
// mem - pointer to memory allocated by allocTempMem function
// vertices - pointer to memory allocated by allocTempMem function
// verticesCountPtr- pointer to value containing number of vertices
// in vertices array
// width - width of image line in pixels
int makeHelpGraph( CvGraph* graph,
CvGraph** hlpGraphPtr,
CvMemStorage* storage,
int* mem,
int* vertices,
int* verticesCountPtr,
int width )
{
int u, v;
int* order = mem;
int* lengthArr = order + width + 2;
int s = graph -> total - 2; /* source vertex */
int t = graph -> total - 1; /* terminate vertex */
int orderFirst;
int orderCount;
int &verticesCount = *verticesCountPtr;
CvGraph* hlpGraph;
if( *hlpGraphPtr ) {
cvClearGraph( *hlpGraphPtr );
}
else {
*hlpGraphPtr = cvCreateGraph( CV_SEQ_KIND_GRAPH |
CV_GRAPH_FLAG_ORIENTED,
sizeof( CvGraph ),
getSizeForGraph( Vertex ),
getSizeForGraph( Edge ),
storage );
}
hlpGraph = *hlpGraphPtr;
/* initialization */
for( u = 0; u < graph -> total; u ++ )
{
lengthArr[ u ] = INT_INFINITY;
cvGraphAddVtx( hlpGraph, NULL, NULL );
} /* for( u = 0; u < graph -> total - 1; u ++ ) */
orderFirst = 0;
orderCount = 0;
verticesCount = 0;
lengthArr[ s ] = 0;
/* add vertex s to order */
order[ orderCount ] = s;
orderCount ++;
while( orderCount != orderFirst )
{
/* getting u from order */
u = order[ orderFirst ];
orderFirst ++;
/* adding u to vertex array */
vertices[ verticesCount ] = u;
verticesCount ++;
int ofs;
CvGraphVtx* graphVtx = cvGetGraphVtx( graph, u );
/* processing all vertices outgoing from vertex u */
CvGraphEdge* graphEdge = graphVtx -> first;
while( graphEdge )
{
int tempVtxIdx = cvGraphVtxIdx( graph, graphEdge -> vtx[1] );
ofs = tempVtxIdx == u;
if( !ofs )
{
v = tempVtxIdx;
CvGraphEdge* tempGraphEdge = cvFindGraphEdge( graph, u, v );
if( ( lengthArr[ u ] < lengthArr[ v ] )
&& ( lengthArr[ v ] <= lengthArr[ t ] )
&& ( ( ( Edge* )tempGraphEdge ) -> flow <
( ( Edge* )tempGraphEdge ) -> weight ) )
{
if( lengthArr[ v ] == INT_INFINITY )
{
/* adding vertex v to order */
order[ orderCount ] = v;
orderCount ++;
lengthArr[ v ] = lengthArr[ u ] + 1;
CvGraphEdge* tempGraphEdge2;
cvGraphAddEdge( hlpGraph, u, v, NULL, &tempGraphEdge2 );
( ( Edge* )tempGraphEdge2 ) -> flow = 0;
( ( Edge* )tempGraphEdge2 ) -> weight =
( ( Edge* )tempGraphEdge ) -> weight -
( ( Edge* )tempGraphEdge ) -> flow;
} /* if( length[ v ] == INT_INFINITY ) */
} /* if( ( lengthArr[ u ] < lengthArr[ v ] ) ... */
} /* if( !ofs ) */
graphEdge = graphEdge -> next[ ofs ];
} /* while( graphEdge ) */
/* processing all vertices incoming to vertex u */
graphEdge = graphVtx -> first;
while( graphEdge )
{
int tempVtxIdx = cvGraphVtxIdx( graph, graphEdge -> vtx[1] );
ofs = tempVtxIdx == u;
if( ofs )
{
tempVtxIdx = cvGraphVtxIdx( graph, graphEdge -> vtx[0] );
v = tempVtxIdx;
CvGraphEdge* tempGraphEdge = cvFindGraphEdge( graph, v, u );
if( ( lengthArr[ u ] < lengthArr[ v ] )
&& ( lengthArr[ v ] <= lengthArr[ t ] )
&& ( ( ( Edge* )tempGraphEdge ) -> flow > 0 ) )
{
if( lengthArr[ v ] == INT_INFINITY )
{
/* adding vertex v to order */
order[ orderCount ] = v;
orderCount ++;
lengthArr[ v ] = lengthArr[ u ] + 1;
CvGraphEdge* tempGraphEdge3 = cvFindGraphEdge( hlpGraph, u, v );
if( tempGraphEdge3 == NULL ||
( ( Edge* )tempGraphEdge3 ) -> weight == 0 )
{
CvGraphEdge* tempGraphEdge2;
cvGraphAddEdge( hlpGraph, u, v, NULL,
&tempGraphEdge2 );
( ( Edge* )tempGraphEdge2 ) -> flow = 0;
( ( Edge* )tempGraphEdge2 ) -> weight = 0;
} /* if( tempGraphEdge3 == NULL || ... */
( ( Edge* )tempGraphEdge3 ) -> weight +=
( ( Edge* )tempGraphEdge ) -> flow;
} /* if( length[ v ] == INT_INFINITY ) */
} /* if( ( lengthArr[ u ] < lengthArr[ v ] ) ... */
} /* if( ofs ) */
graphEdge = graphEdge -> next[ ofs ];
} /* while( graphEdge ) */
} /* while( orderCount != orderFirst ) */
int i;
for( i = 0; i < hlpGraph -> total - 2; i ++ )
{
CvGraphVtx* hlpGraphVtxTemp = cvGetGraphVtx( hlpGraph, i );
if( hlpGraphVtxTemp ) {
if( !hlpGraphVtxTemp -> first ) {
cvGraphRemoveVtxByPtr( hlpGraph, hlpGraphVtxTemp );
}
}
} /* for( i = 0; i < hlpGraph -> total - 2; i ++ ) */
return lengthArr[ t ];
} /* makeHelpGraph */
// function makePseudoMaxFlow increases flow in graph by using hlpGraph
// graph - pointer to initial graph
// hlpGraph - pointer to help graph
// vertices - pointer to vertices array
// verticesCount - number of vertices in vertices array
// mem - pointer to memory allocated by allocTempMem function
// width - width of image line in pixels
void makePseudoMaxFlow( CvGraph* graph,
CvGraph* hlpGraph,
int* vertices,
int verticesCount,
int* mem,
int width )
{
int stekCount;
int orderFirst;
int orderCount;
int i;
int v, u;
int* stek = mem;
int* order = stek + width + 2;
int* incomFlow = order + width + 2;
int* outgoFlow = incomFlow + width + 2;
int* flow = outgoFlow + width + 2;
int* cargo = flow+ width + 2;
int s = graph -> total - 2; /* source vertex */
int t = graph -> total - 1; /* terminate vertex */
int realVerticesCount = verticesCount;
stekCount = 0;
for( i = 0; i < verticesCount; i ++ )
{
v = vertices[ i ];
incomFlow[ v ] = outgoFlow[ v ] = 0;
if( v == s ) {
incomFlow[ v ] = INT_INFINITY;
} /* if( v == s ) */
else {
CvGraphVtx* hlpGraphVtx = cvGetGraphVtx( hlpGraph, v );
CvGraphEdge* hlpGraphEdge = hlpGraphVtx -> first;
int ofs;
while( hlpGraphEdge )
{
int vtxIdx = cvGraphVtxIdx( hlpGraph,
hlpGraphEdge -> vtx[1] );
ofs = vtxIdx == v;
if( ofs )
{
incomFlow[ v ] += ( ( Edge* )hlpGraphEdge ) -> weight;
} /* if( ofs ) */
hlpGraphEdge = hlpGraphEdge -> next[ ofs ];
} /* while( hlpGraphEdge ) */
} /* if( v == s ) else */
if( v == t ) {
outgoFlow[ v ] = INT_INFINITY;
} /* if( v == t ) */
else {
CvGraphVtx* hlpGraphVtx = cvGetGraphVtx( hlpGraph, v );
CvGraphEdge* hlpGraphEdge = hlpGraphVtx -> first;
int ofs;
while( hlpGraphEdge )
{
int vtxIdx = cvGraphVtxIdx( hlpGraph,
hlpGraphEdge -> vtx[1] );
ofs = vtxIdx == v;
if( !ofs )
{
outgoFlow[ v ] += ( ( Edge* )hlpGraphEdge ) -> weight;
} /* if( ofs ) */
hlpGraphEdge = hlpGraphEdge -> next[ ofs ];
} /* while( hlpGraphEdge ) */
} /* if( v == t ) else */
flow[ v ] = CV_MIN2( incomFlow[ v ], outgoFlow[ v ] );
if( !flow[ v ] ) {
stek[ stekCount ] = v;
stekCount ++;
} /* if( !flow[ v ] ) */
} /* for( i = 0; i < verticesCount; i ++ ) */
for( i = 0; i < verticesCount; i ++ )
{
v = vertices[ i ];
cargo[ v ] = 0;
} /* for( i = 0; i < verticesCount; i ++ ) */
while( realVerticesCount > 2 )
{
/* deleting all vertices included in stek */
while( stekCount )
{
v = stek[ stekCount - 1 ];
stekCount --;
/* deleting edges incoming to v and outgoing from v */
int ofs;
CvGraphVtx* hlpGraphVtx = cvGetGraphVtx( hlpGraph, v );
CvGraphEdge* hlpGraphEdge;
if( hlpGraphVtx ) {
hlpGraphEdge = hlpGraphVtx -> first;
}
else {
hlpGraphEdge = NULL;
}
while( hlpGraphEdge )
{
CvGraphVtx* hlpGraphVtx2 = hlpGraphEdge -> vtx[ 1 ];
int hlpGraphVtxIdx2 = cvGraphVtxIdx( hlpGraph,
hlpGraphVtx2 );
ofs = hlpGraphVtxIdx2 == v;
if( ofs )
{
/* hlpGraphEdge is incoming edge */
CvGraphVtx* hlpGraphVtx3 = hlpGraphEdge -> vtx[0];
u = cvGraphVtxIdx( hlpGraph,
hlpGraphVtx3 );
outgoFlow[ u ] -= ( ( Edge* )hlpGraphEdge ) -> weight
- ( ( Edge* )hlpGraphEdge ) -> flow;
cvGraphRemoveEdgeByPtr( hlpGraph,
hlpGraphVtx3,
hlpGraphVtx2 );
if( flow[ u ] != 0 ) {
flow[ u ] = CV_MIN2( incomFlow[u], outgoFlow[u] );
if( flow[ u ] == 0 ) {
stek[ stekCount ] = u;
stekCount ++;
}
}
} /* if( ofs ) */
else
{
/* hlpGraphEdge is outgoing edge */
CvGraphVtx* hlpGraphVtx3 = hlpGraphEdge -> vtx[1];
int u = cvGraphVtxIdx( hlpGraph,
hlpGraphVtx3 );
incomFlow[ u ] -= ( ( Edge* )hlpGraphEdge ) -> weight
- ( ( Edge* )hlpGraphEdge ) -> flow;
cvGraphRemoveEdgeByPtr( hlpGraph,
hlpGraphVtx2,
hlpGraphVtx3 );
if( flow[ u ] != 0 ) {
flow[ u ] = CV_MIN2( incomFlow[u], outgoFlow[u] );
if( flow[ u ] == 0 ) {
stek[ stekCount ] = u;
stekCount ++;
}
}
} /* if( ofs ) else */
hlpGraphEdge = hlpGraphEdge -> next[ ofs ];
} /* while( hlpGraphEdge ) */
/* deleting vertex v */
cvGraphRemoveVtx( hlpGraph, v );
realVerticesCount --;
} /* while( stekCount ) */
if( realVerticesCount > 2 ) /* the flow is not max still */
{
int p = INT_INFINITY;
int r = -1;
CvGraphVtx* graphVtx;
if( realVerticesCount == 3 ) {
r = r;
}
for( i = 0; i < hlpGraph -> total - 2; i ++ )
{
graphVtx = cvGetGraphVtx( hlpGraph, i );
if( graphVtx ) {
v = cvGraphVtxIdx( hlpGraph, graphVtx );
if( flow[ v ] < p ) {
r = v;
p = flow[ v ];
}
}
} /* for( i = 0; i < hlpGraph -> total - 2; i ++ ) */
/* building of size p flow from r to t */
orderCount = orderFirst = 0;
order[ orderCount ] = r;
orderCount ++;
v = order[ orderFirst ];
orderFirst ++;
cargo[ r ] = p;
do /* while( v != t ) */
{
incomFlow[ v ] -= cargo[ v ];
outgoFlow[ v ] -= cargo[ v ];
flow[ v ] -= cargo[ v ];
if( flow[ v ] == 0 ) {
stek[ stekCount ] = v;
stekCount ++;
}
if( v == t ) {
cargo[ v ] = p;
}
else
{
int ofs;
CvGraphVtx* hlpGraphVtx2;
CvGraphVtx* hlpGraphVtx = cvGetGraphVtx( hlpGraph, v );
CvGraphEdge* hlpGraphEdge = hlpGraphVtx -> first;
CvGraphEdge* hlpGraphEdge2 = NULL;
while( hlpGraphEdge && cargo[ v ] > 0 )
{
hlpGraphVtx2 = hlpGraphEdge -> vtx[ 1 ];
u = cvGraphVtxIdx( hlpGraph, hlpGraphVtx2 );
ofs = u == v;
if( !ofs )
{
if( cargo[ u ] == 0 ) {
order[ orderCount ] = u;
orderCount ++;
}
int delta = ( ( Edge* )hlpGraphEdge ) -> weight
- ( ( Edge* )hlpGraphEdge ) -> flow;
delta = CV_MIN2( cargo[ v ], delta );
( ( Edge* )hlpGraphEdge ) -> flow += delta;
cargo[ v ] -= delta;
cargo[ u ] += delta;
if( ( ( Edge* )hlpGraphEdge ) -> weight ==
( ( Edge* )hlpGraphEdge ) -> flow )
{
/* deleting hlpGraphEdge */
hlpGraphEdge2 = hlpGraphEdge -> next[ ofs ];
CvGraphEdge* graphEdge =
cvFindGraphEdge( graph, v, u );
( ( Edge* )graphEdge ) -> flow +=
( ( Edge* )hlpGraphEdge ) -> flow;
cvGraphRemoveEdgeByPtr( hlpGraph,
hlpGraphEdge -> vtx[0],
hlpGraphEdge -> vtx[1] );
}
} /* if( !ofs ) */
if( hlpGraphEdge2 ) {
hlpGraphEdge = hlpGraphEdge2;
hlpGraphEdge2 = NULL;
}
else {
hlpGraphEdge = hlpGraphEdge -> next[ ofs ];
}
} /* while( hlpGraphEdge && cargo[ v ] > 0 ) */
} /* if( v == t ) else */
v = order[ orderFirst ];
orderFirst ++;
} while( v != t ); /* do */
/* building of size p flow from s to r */
orderCount = orderFirst = 0;
order[ orderCount ] = r;
orderCount ++;
v = order[ orderFirst ];
orderFirst ++;
cargo[ r ] = p;
do /* while( v != s ) */
{
if( v != r )
{
incomFlow[ v ] -= cargo[ v ];
outgoFlow[ v ] -= cargo[ v ];
flow[ v ] -= cargo[ v ];
if( flow[ v ] == 0 ) {
stek[ stekCount ] = v;
stekCount ++;
}
} /* if( v != r ) */
if( v == s ) {
cargo[ v ] = 0;
} /* if( v == s ) */
else
{
int ofs;
CvGraphVtx* hlpGraphVtx = cvGetGraphVtx( hlpGraph, v );
CvGraphEdge* hlpGraphEdge = hlpGraphVtx -> first;
CvGraphEdge* hlpGraphEdge2 = NULL;
while( hlpGraphEdge && cargo[ v ] > 0 )
{
u = cvGraphVtxIdx( hlpGraph,
hlpGraphEdge -> vtx[ 1 ] );
ofs = u == v;
if( ofs )
{
u = cvGraphVtxIdx( hlpGraph,
hlpGraphEdge -> vtx[ 0 ] );
if( cargo[ u ] == 0 ) {
order[ orderCount ] = u;
orderCount ++;
}
int delta = ( ( Edge* )hlpGraphEdge ) -> weight
- ( ( Edge* )hlpGraphEdge ) -> flow;
delta = CV_MIN2( cargo[ v ], delta );
(( ( Edge* )hlpGraphEdge ) -> flow) += delta;
cargo[ v ] -= delta;
cargo[ u ] += delta;
if( ( ( Edge* )hlpGraphEdge ) -> weight ==
( ( Edge* )hlpGraphEdge ) -> flow )
{
hlpGraphEdge2 = hlpGraphEdge -> next[ ofs ];
CvGraphEdge* graphEdge =
cvFindGraphEdge( graph, u, v );
( ( Edge* )graphEdge ) -> flow +=
( ( Edge* )hlpGraphEdge ) -> flow;
cvGraphRemoveEdgeByPtr( hlpGraph,
hlpGraphEdge -> vtx[0],
hlpGraphEdge -> vtx[1] );
}
} /* if( ofs ) */
if( hlpGraphEdge2 ) {
hlpGraphEdge = hlpGraphEdge2;
hlpGraphEdge2 = NULL;
}
else {
hlpGraphEdge = hlpGraphEdge -> next[ ofs ];
}
} /* while( hlpGraphEdge && cargo[ v ] > 0 ) */
} /* if( v == s ) else */
v = order[ orderFirst ]; //added
orderFirst ++; //added
} while( v != s ); /* do */
} /* if( hlpGraph -> total > 2 ) */
} /* while( hlpGraph -> total > 2 ) */
} /* makePseudoMaxFlow */
// function oneStep produces one alpha-beta exchange for one line of images
// leftLine - pointer to the left image line
// rightLine - pointer to the right image line
// alpha - label number one
// beta - label number two
// corr - pointer to correspondence array for this line
// width - width of image line in pixels
// mem - pointer to memory allocated by allocTempMem function
// vertices - pointer to vertices array allocated by allocTempMem
// function
// storage - pointer to CvMemStorage structure
bool oneStep( unsigned char* leftLine,
unsigned char* rightLine,
int alpha,
int beta,
int* corr,
int width,
int* mem,
int* vertices,
CvMemStorage* storage )
{
CvGraph* graph = NULL;
CvGraph* hlpGraph = NULL;
CvMemStoragePos storagePos;
int i;
bool change = false;
cvSaveMemStoragePos( storage, &storagePos );
int verticesCount;
makeGraph( &graph, leftLine, rightLine, alpha, beta, corr, width, storage );
int s = graph -> total - 2; /* source vertex - alpha vertex */
//int t = graph -> total - 1; /* terminate vertex - beta vertex */
int length = makeHelpGraph( graph,
&hlpGraph,
storage,
mem,
vertices,
&verticesCount,
width );
while( length != INT_INFINITY )
{
change = true;
makePseudoMaxFlow( graph,
hlpGraph,
vertices,
verticesCount,
mem,
width );
cvClearGraph( hlpGraph );
length = makeHelpGraph( graph,
&hlpGraph,
storage,
mem,
vertices,
&verticesCount,
width );
} /* while( length != INT_INFINITY ) */
int coord;
CvGraphVtx* graphVtx;
for( i = 0; i < s; i ++ )
{
CvGraphEdge* graphEdge = cvFindGraphEdge( graph, s, i );
if( ( ( Edge* )graphEdge ) -> weight ==
( ( Edge* )graphEdge ) -> flow )
{ /* this vertex must have alpha label */
graphVtx = cvGetGraphVtx( graph, i );
coord = ( ( Vertex* )graphVtx )-> coord;
if( corr[ coord ] != alpha ) {
corr[ coord ] = alpha; //added
change = true;
}
else {
corr[ coord ] = alpha;
}
} /* if( ( ( Edge* )graphEdge ) -> weight == ... */
else
{ /* this vertex must have beta label */
graphVtx = cvGetGraphVtx( graph, i );
coord = ( ( Vertex* )graphVtx )-> coord;
if( corr[ coord ] != beta ) {
corr[ coord ] = beta; //added
change = true;
}
else {
corr[ coord ] = beta;
}
} /* if( ( ( Edge* )graphEdge ) -> weight == ... else */
} /* for( i = 0; i < s; i ++ ) */
cvClearGraph( hlpGraph );
cvClearGraph( graph );
cvRestoreMemStoragePos( storage, &storagePos );
return change;
} /* oneStep */
// function initCorr fills correspondence array with initial values
// corr - pointer to correspondence array for this line
// width - width of image line in pixels
// maxPixelDifference - maximum value of difference between the same
// point painted on two images
void initCorr( int* corr, int width, int maxPixelDifference )
{
int i;
int pixelDifferenceRange = maxPixelDifference * 2 + 1;
for( i = 0; i < width; i ++ )
{
corr[ i ] = i % pixelDifferenceRange - maxPixelDifference;
}
} /* initCorr */
// function oneLineCorr fully computes one line of images
// leftLine - pointer to the left image line
// rightLine - pointer to the right image line
// corr - pointer to the correspondence array for one
// line
// mem - pointer to memory allocated by allocTempMem
// function
// vertices - pointer to memory allocated by allocTempMem
// function
// width - width of image line in pixels
// maxPixelDifference - maximum value of pixel differences in pixels
// storage - pointer to CvMemStorage struct which
// contains memory storage
void oneLineCorr( unsigned char* leftLine,
unsigned char* rightLine,
int* corr,
int* mem,
int* vertices,
int width,
int maxPixelDifference,
CvMemStorage* storage )
{
int result = 1;
int count = 0;
int i, j;
initCorr( corr, width, maxPixelDifference );
while( result )
{
result = 0;
for( i = - maxPixelDifference; i < maxPixelDifference; i ++ )
for( j = i + 1; j <= maxPixelDifference; j ++ )
{
result += (int)oneStep( leftLine,
rightLine,
i,
j,
corr,
width,
mem,
vertices,
storage );
} /* for( j = i + 1; j < width; j ++ ) */
count ++;
if( count > /*0*//*1*/2 ) {
break;
}
} /* while( result ) */
} /* oneLineCorr */
// function allLinesCorr computes all lines on the images
// leftImage - pointer to the left image
// leftLineStep - size of line on the left image in bytes
// rightImage - pointer to the right image
// rightLineStep - size of line on the right image in bytes
// width - width of line in pixels
// height - height of image in pixels
// corr - pointer to correspondence array for all lines
// maxPixelDifference - maximum value of difference between the same
// point painted on two images
// storage - pointer to CvMemStorage which contains memory
// storage
void allLinesCorr( unsigned char* leftImage,
int leftLineStep,
unsigned char* rightImage,
int rightLineStep,
int width,
int height,
int* corr,
int maxPixelDifference,
CvMemStorage* storage )
{
int i;
unsigned char* leftLine = leftImage;
unsigned char* rightLine = rightImage;
int* mem;
int* vertices;
allocTempMem( &mem,
&vertices,
width );
for( i = 0; i < height; i ++ )
{
oneLineCorr( leftLine,
rightLine,
corr + i * width,
mem,
vertices,
width,
maxPixelDifference,
storage );
leftLine += leftLineStep;
rightLine += rightLineStep;
} /* for( i = 0; i < height; i ++ ) */
freeTempMem( &mem,
&vertices );
} /* allLinesCorr */
// This function produces morphing of two images into one image, which includes morphed
// image or depth map
// _leftImage - pointer to left image
// _leftLineStep - size of line on left image in bytes
// _rightImage - pointer to right image
// _rightLineStep - size of line on right image in bytes
// _resultImage - pointer to result morphed image
// _resultLineStep - size of line on result image in bytes
// _corrArray - pointer to array with correspondences
// _numCorrArray - pointer to array with numbers correspondeces on each line
// width - width of images
// height - height of images
// alpha - position of virtual camera ( 0 corresponds to left image, 1 - to right one )
// imageNeed - defines your wishes. if you want to see normal morphed image you have to set
// this parameter to morphNormalImage ( this is default value ), else if you want
// to see depth map you have to set this parameter to morphDepthMap and set the
// next parameter ( maxPixelDifference ) to real value
// maxPixelDifference - maximum value of pixel difference on two images
void CCvGraphCutMorpher::Morph( unsigned char* _leftImage,
int _leftLineStep,
unsigned char* _rightImage,
int _rightLineStep,
unsigned char* _resultImage,
int _resultLineStep,
int* _corrArray,
int width,
int height,
float alpha,
morphImageType imageNeed,
int maxDifference
)
{
unsigned char* leftArray = _leftImage;
unsigned char* middleArray = _resultImage;
unsigned char* rightArray = _rightImage;
int leftLineSize = _leftLineStep;
int middleLineSize = _resultLineStep;
int rightLineSize = _rightLineStep;
int lineNumber;
unsigned char* leftTemp;
unsigned char* middleTemp;
unsigned char* rightTemp;
int leftPixel;
int prevLeftPixel;
int middlePixel;
int prevMiddlePixel;
int rightPixel;
int prevRightPixel;
int leftPixel3;
int middlePixel3;
int rightPixel3;
int i;
int j;
int tempIndex;
int* result;
int number;
float alpha1 = 1.0f - alpha;
for( lineNumber = 0; lineNumber < height; lineNumber ++ )
{
leftTemp = leftArray + leftLineSize * lineNumber;
middleTemp = middleArray + middleLineSize * lineNumber;
rightTemp = rightArray + rightLineSize * lineNumber;
memset( ( void* )middleTemp, 0, middleLineSize );
result = _corrArray + width * lineNumber;
number = width;
prevLeftPixel = 0;
prevRightPixel = prevLeftPixel + result[ 0 ];
if( prevRightPixel >= width ) {
prevRightPixel = width - 1;
}
else if ( prevRightPixel < 0 ) {
prevRightPixel = 0;
}
prevMiddlePixel =
(int)( prevLeftPixel * alpha1 + prevRightPixel * alpha );
for( i = 0; i < number - 1; i ++ )
{
leftPixel = i;
rightPixel = i + result[ i ];
if( rightPixel >= width ) {
rightPixel = width - 1;
}
else if( rightPixel < 0 ) {
rightPixel = 0;
}
middlePixel =
(int)( leftPixel * alpha1 + rightPixel * alpha );
leftPixel3 = leftPixel * 3;
middlePixel3 = middlePixel * 3;
rightPixel3 = rightPixel * 3;
if( imageNeed == morphDepthMap ) {
int t = leftPixel - rightPixel + maxDifference;
t = t < 0 ? -t : t;
t = t * 255 / maxDifference / 2;
middleTemp[ middlePixel3 ] = ( unsigned char )t;
middleTemp[ middlePixel3 + 1 ] = ( unsigned char )t;
middleTemp[ middlePixel3 + 2 ] = ( unsigned char )t;
} // if( imageNeed == morphDepthMap )
else
{
middleTemp[ middlePixel3 ] =
(unsigned char)( leftTemp[ leftPixel3 ] * alpha1
+ rightTemp[ rightPixel3 ] * alpha );
middleTemp[ middlePixel3 + 1 ] =
(unsigned char)( leftTemp[ leftPixel3 + 1 ] * alpha1
+ rightTemp[ rightPixel3 + 1 ] * alpha );
middleTemp[ middlePixel3 + 2 ] =
(unsigned char)( leftTemp[ leftPixel3 + 2 ] * alpha1
+ rightTemp[ rightPixel3 + 2 ] * alpha );
if( middlePixel - prevMiddlePixel > 1 ) // occlusion
{
if( leftPixel - prevLeftPixel > 1 )
{
int LenSrc = leftPixel - prevLeftPixel - 2;
int LenDest = middlePixel - prevMiddlePixel - 1;
for( j = prevMiddlePixel + 1; j < middlePixel; j ++ )
{
tempIndex = prevLeftPixel + 1 + LenSrc *
( j - prevMiddlePixel - 1 ) / LenDest;
middleTemp[ j * 3 ] =
leftTemp[ tempIndex * 3 ];
middleTemp[ j * 3 + 1 ] =
leftTemp[ tempIndex * 3 + 1 ];
middleTemp[ j * 3 + 2 ] =
leftTemp[ tempIndex * 3 + 2 ];
}
} // if( leftPixel - prevLeftPixel > 1 )
else
{
int LenSrc = rightPixel - prevRightPixel - 2;
int LenDest = middlePixel - prevMiddlePixel - 1;
for( j = prevMiddlePixel + 1; j < middlePixel; j ++ )
{
tempIndex = prevRightPixel + 1 + LenSrc *
( j - prevMiddlePixel - 1 ) / LenDest;
middleTemp[ j * 3 ] =
rightTemp[ tempIndex * 3 ];
middleTemp[ j * 3 + 1 ] =
rightTemp[ tempIndex * 3 + 1 ];
middleTemp[ j * 3 + 2 ] =
rightTemp[ tempIndex * 3 + 2 ];
}
} // if( leftPixel - prevLeftPixel > 1 ) else
} // if( middlePixel - prevMiddlePixel > 1 )
} // if( imageNeed == morphDepthMap ) else
if( middlePixel > prevMiddlePixel ) {
if( leftPixel > prevLeftPixel )
prevLeftPixel = leftPixel;
if( rightPixel > prevRightPixel )
prevRightPixel = rightPixel;
prevMiddlePixel = middlePixel;
}
} // for( i = number - 1; i >= 0; i -- )
} // for( lineNumber = 0; lineNumber < LeftImage -> m_Raster -> GetHeight() )
} // Morph
bool CCvGraphCutMorpher::OnCalculateStereo()
{
CvSize imageSizeLeft = GetImageSize( m_left_img ),
imageSizeRight = GetImageSize( m_right_img );
if( ( imageSizeLeft.width != imageSizeRight.width )
|| ( imageSizeLeft.height != imageSizeRight.height ) )
{
return false;
}
if( m_corr ) {
free( m_corr );
m_corr = NULL;
}
m_corr = ( int* ) malloc( m_left_img -> width
* m_left_img -> height
* sizeof( int ) );
if( !m_storage ) {
m_storage = cvCreateMemStorage( 0 );
m_isStorageAllocated = true;
}
// Find correspondence for full image and store it to corr array
allLinesCorr( ( unsigned char* )m_left_img -> imageData,
m_left_img -> widthStep,
( unsigned char* )m_right_img -> imageData,
m_right_img -> widthStep,
m_left_img -> width,
m_left_img -> height,
m_corr,
m_maxPixelDifference,
m_storage );
m_isStereoReady = true;
return true;
}
bool CCvGraphCutMorpher::OnCalculateVirtualImage()
{
// Output image to ResultImage window
Morph( ( unsigned char* )m_left_img -> imageData,
m_left_img ->widthStep,
( unsigned char* )m_right_img -> imageData,
m_right_img -> widthStep,
( unsigned char* )m_virtual_img -> imageData,
m_virtual_img -> widthStep,
m_corr,
m_left_img -> width,
m_left_img -> height,
m_pan );
m_isVirtualImageReady = true;
return true;
}
bool CCvGraphCutMorpher::OnCalculateDisparity()
{
Morph( ( unsigned char* )m_left_img -> imageData,
m_left_img ->widthStep,
( unsigned char* )m_right_img -> imageData,
m_right_img -> widthStep,
( unsigned char* )m_disparity_img -> imageData,
m_disparity_img -> widthStep,
m_corr,
m_left_img -> width,
m_left_img -> height,
m_pan,
morphDepthMap,
m_maxPixelDifference );
return true;
}
bool CCvGraphCutMorpher::OnCalculateDisparityImage()
{
Morph( ( unsigned char* )m_left_img -> imageData,
m_left_img ->widthStep,
( unsigned char* )m_right_img -> imageData,
m_right_img -> widthStep,
( unsigned char* )m_disparity_img -> imageData,
m_disparity_img -> widthStep,
m_corr,
m_left_img -> width,
m_left_img -> height,
m_pan,
morphDepthMap,
m_maxPixelDifference );
return true;
}
CCvGraphCutMorpher::CCvGraphCutMorpher()
{
m_maxPixelDifference = MAX_DIFFERENCE;
m_corr = 0;
m_isStereoReady = false;
m_isVirtualImageReady = false;
m_isDisparityReady = false;
m_storage = NULL;
m_isStorageAllocated = false;
}
#endif
/* End of file */
Reference in New Issue View Git Blame Copy Permalink