cvaux/src/cvlcm.cpp

/*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*/

/* Hybrid linear-contour model reconstruction */
#include "_cvaux.h"

#define CV_IMPL CV_EXTERN_C

const float LCM_CONST_ZERO = 1e-6f;

/****************************************************************************************\
*                                    Auxiliary struct definitions                                 *
\****************************************************************************************/
typedef struct CvLCM
{
    CvGraph* Graph;
    CvVoronoiDiagram2D* VoronoiDiagram;
    CvMemStorage* ContourStorage;
    CvMemStorage* EdgeStorage;
    float maxWidth;
} CvLCM;

typedef struct CvLCMComplexNodeData
{
    CvVoronoiNode2D edge_node;
    CvPoint2D32f site_first_pt;
    CvPoint2D32f site_last_pt;
    CvVoronoiSite2D* site_first;
    CvVoronoiSite2D* site_last;
    CvVoronoiEdge2D* edge;
} CvLCMComplexNodeData;

typedef struct CvLCMData
{
    CvVoronoiNode2D* pnode;
    CvVoronoiSite2D* psite;
    CvVoronoiEdge2D* pedge;
} CvLCMData;


/****************************************************************************************\
*                                    Function definitions                                *
\****************************************************************************************/

#define _CV_READ_SEQ_ELEM( elem, reader, type )                       \
{                                                              \
    assert( (reader).seq->elem_size == sizeof(*elem));         \
    elem = (type)(reader).ptr;                                 \
    CV_NEXT_SEQ_ELEM( sizeof(*elem), reader )                  \
}

#define _CV_IS_SITE_REFLEX( SITE )  ((SITE) ->node[0] == (SITE) ->node[1])
#define _CV_IS_EDGE_REFLEX( EDGE )  (( (EDGE)->site[0]->node[0] == (EDGE)->site[0]->node[0] ) || \
                                      ( (EDGE)->site[1]->node[0] == (EDGE)->site[1]->node[0] ) )

#define _CV_INITIALIZE_CVLCMDATA(STRUCT,SITE,EDGE,NODE)\
{ (STRUCT)->psite = SITE ; (STRUCT)->pedge = EDGE; (STRUCT)->pnode = NODE;}
/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvConstructLCM
//    Purpose: Function constructs hybrid model
//    Context:
//    Parameters:
//      LCM : in&out.
//    Returns: 1, if hybrid model was succesfully constructed
//             0, if some error occures
//F*/
CV_IMPL
int _cvConstructLCM(CvLCM* LCM);

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvConstructLCMComplexNode
//    Purpose: Function constructs Complex Node (node, which consists of
//             two points and more) of hybrid model
//    Context:
//    Parameters:
//      pLCM : in&out.
//      pLCMEdge: in, input edge of hybrid model
//      pLCMInputData: in, input parameters
//    Returns: pointer to constructed node
//F*/
CV_IMPL
CvLCMNode* _cvConstructLCMComplexNode(CvLCM* pLCM,
                                      CvLCMEdge* pLCMEdge,
                                      CvLCMData* pLCMInputData);

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvConstructLCMSimpleNode
//    Purpose: Function constructs Simple Node (node, which consists of
//             one point) of hybrid model
//    Context:
//    Parameters:
//      pLCM : in&out.
//      pLCMEdge: in, input edge of hybrid model
//      pLCMInputData: in, input parameters
//    Returns: pointer to constructed node
//F*/
CV_IMPL
CvLCMNode* _cvConstructLCMSimpleNode(CvLCM* pLCM,
                                    CvLCMEdge* pLCMEdge,
                                    CvLCMData* pLCMInputData);

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvConstructLCMSimpleNode
//    Purpose: Function constructs Edge of hybrid model
//    Context:
//    Parameters:
//      pLCM : in&out.
//      pLCMInputData: in, input parameters
//    Returns: pointer to constructed edge
//F*/
CV_IMPL
CvLCMEdge* _cvConstructLCMEdge(CvLCM* pLCM,
                               CvLCMData* pLCMInputData);

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvTreatExeptionalCase
//    Purpose: Function treats triangles and regular polygons
//    Context:
//    Parameters:
//      pLCM : in, information about graph
//      pLCMInputData: in, input parameters
//    Returns: pointer to graph node
//F*/
CV_IMPL
CvLCMNode* _cvTreatExeptionalCase(CvLCM* pLCM,
                                  CvLCMData* pLCMInputData);

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvNodeMultyplicity
//    Purpose: Function seeks all non-boundary edges incident to
//              given node and correspondent incident sites
//    Context:
//    Parameters:
//      pEdge : in, original edge
//      pNode : in, given node
//      LinkedEdges : out, matrix of incident edges
//      LinkedSites : out, matrix of incident sites
//      pSite: in, original site (pNode must be the begin point of pEdge
//              for this pSite, this property hold out far all edges)
//    Returns: number of incident edges (must be less than 10)
//F*/
CV_IMPL
int _cvNodeMultyplicity(CvVoronoiSite2D* pSite,
                        CvVoronoiEdge2D* pEdge,
                        CvVoronoiNode2D* pNode,
                        CvVoronoiEdge2D** LinkedEdges,
                        CvVoronoiSite2D** LinkedSites);

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvCreateLCMNode
//    Purpose: Function create graph node
//    Context:
//    Parameters:
//      pLCM : in, information about graph
//    Returns: pointer to graph node
//F*/
CV_IMPL
CvLCMNode* _cvCreateLCMNode(CvLCM* pLCM);

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvCreateLCMEdge
//    Purpose: Function create graph edge
//    Context:
//    Parameters:
//      pLCM : in, information about graph
//    Returns: pointer to graph edge
//F*/
CV_IMPL
CvLCMEdge* _cvCreateLCMEdge(CvLCM* pLCM);

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvCreateLCMNode
//    Purpose: Function establishs the connection between node and ege
//    Context:
//    Parameters:
//      LCMNode : in, graph node
//      LCMEdge : in, graph edge
//      LCMEdge_prev : in&out, previous edge, connected with given node
//      index: in,
//      i    : =0, if node is initial for edge
//             =1, if node  is terminal for edge
//    Returns:
//F*/
CV_IMPL
void _cvAttachLCMEdgeToLCMNode(CvLCMNode* LCMNode,
                               CvLCMEdge* LCMEdge,
                               CvLCMEdge* &LCMEdge_prev,
                               int index,
                               int i);
/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvProjectionPointToSegment
//    Purpose: Function computes the ortogonal projection of PointO to
//             to segment[PointA, PointB]
//    Context:
//    Parameters:
//      PointO, PointA,PointB: in, given points
//      PrPoint : out, projection
//      dist : distance from PointO to PrPoint
//    Returns:
//F*/
CV_IMPL
void _cvProjectionPointToSegment(CvPoint2D32f* PointO,
                                 CvPoint2D32f* PointA,
                                 CvPoint2D32f* PointB,
                                 CvPoint2D32f* PrPoint,
                                 float* dist);

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Author:  Andrey Sobolev
//    Name:    _cvPrepareData
//    Purpose: Function fills up the struct CvLCMComplexNodeData
//    Context:
//    Parameters:
//      pLCMData : in
//      pLCMCCNData : out
//    Returns:
//F*/
CV_IMPL
void _cvPrepareData(CvLCMComplexNodeData* pLCMCCNData,
                    CvLCMData* pLCMData);

/****************************************************************************************\
*                                    Function realization                               *
\****************************************************************************************/

CV_IMPL CvGraph* cvLinearContorModelFromVoronoiDiagram(CvVoronoiDiagram2D* VoronoiDiagram,
                                                       float maxWidth)
{
    CvMemStorage* LCMstorage;
    CvSet* SiteSet;
    CvLCM LCM = {NULL, VoronoiDiagram,NULL,NULL,maxWidth};

    CV_FUNCNAME( "cvLinearContorModelFromVoronoiDiagram" );
     __BEGIN__;

    if( !VoronoiDiagram )
        CV_ERROR( CV_StsBadArg,"Voronoi Diagram is not defined" );
    if( maxWidth < 0 )
        CV_ERROR( CV_StsBadArg,"Treshold parameter must be non negative" );

    for(SiteSet = VoronoiDiagram->sites;
        SiteSet != NULL;
        SiteSet = (CvSet*)SiteSet->h_next)
        {
            if(SiteSet->v_next)
                CV_ERROR( CV_StsBadArg,"Can't operate with multiconnected domains" );
            if(SiteSet->total > 70000)
                CV_ERROR( CV_StsBadArg,"Can't operate with large domains" );
        }


    LCMstorage = cvCreateMemStorage(0);
    LCM.EdgeStorage = cvCreateChildMemStorage(LCMstorage);
    LCM.ContourStorage = cvCreateChildMemStorage(LCMstorage);
    LCM.Graph = cvCreateGraph(CV_SEQ_KIND_GRAPH|CV_GRAPH_FLAG_ORIENTED,
                              sizeof(CvGraph),
                              sizeof(CvLCMNode),
                              sizeof(CvLCMEdge),
                              LCMstorage);
    if(!_cvConstructLCM(&LCM))
        cvReleaseLinearContorModelStorage(&LCM.Graph);


    __END__;
    return LCM.Graph;
}//end of cvLinearContorModelFromVoronoiDiagram

CV_IMPL int cvReleaseLinearContorModelStorage(CvGraph** Graph)
{
    CvSeq* LCMNodeSeq, *LCMEdgeSeq;
    CvLCMNode* pLCMNode;
    CvLCMEdge* pLCMEdge;

    /*CV_FUNCNAME( "cvReleaseLinearContorModelStorage" );*/
     __BEGIN__;

    if(!Graph || !(*Graph))
        return 0;

    LCMNodeSeq = (CvSeq*)(*Graph);
    LCMEdgeSeq = (CvSeq*)(*Graph)->edges;
    if(LCMNodeSeq->total > 0)
    {
        pLCMNode = (CvLCMNode*)cvGetSeqElem(LCMNodeSeq,0);
        if(pLCMNode->contour->storage)
            cvReleaseMemStorage(&pLCMNode->contour->storage);
    }
    if(LCMEdgeSeq->total > 0)
    {
        pLCMEdge = (CvLCMEdge*)cvGetSeqElem(LCMEdgeSeq,0);
        if(pLCMEdge->chain->storage)
            cvReleaseMemStorage(&pLCMEdge->chain->storage);
    }
    if((*Graph)->storage)
        cvReleaseMemStorage(&(*Graph)->storage);
    *Graph = NULL;


    __END__;
    return 1;
}//end of cvReleaseLinearContorModelStorage

int _cvConstructLCM(CvLCM* LCM)
{
    CvVoronoiSite2D* pSite = 0;
    CvVoronoiEdge2D* pEdge = 0, *pEdge1;
    CvVoronoiNode2D* pNode, *pNode1;

    CvVoronoiEdge2D* LinkedEdges[10];
    CvVoronoiSite2D* LinkedSites[10];

    CvSeqReader reader;
    CvLCMData LCMdata;
    int i;

    for(CvSet* SiteSet = LCM->VoronoiDiagram->sites;
        SiteSet != NULL;
        SiteSet = (CvSet*)SiteSet->h_next)
    {
        cvStartReadSeq((CvSeq*)SiteSet, &reader);
        for(i = 0; i < SiteSet->total; i++)
        {
            _CV_READ_SEQ_ELEM(pSite,reader,CvVoronoiSite2D*);
            if(pSite->node[0] == pSite->node[1])
                continue;
            pEdge = CV_LAST_VORONOIEDGE2D(pSite);
            pNode = CV_VORONOIEDGE2D_BEGINNODE(pEdge,pSite);
            if(pNode->radius > LCM->maxWidth)
                goto PREPARECOMPLEXNODE;

            pEdge1 = CV_PREV_VORONOIEDGE2D(pEdge,pSite);
            pNode1 = CV_VORONOIEDGE2D_BEGINNODE(pEdge1,pSite);
            if(pNode1->radius > LCM->maxWidth)
                goto PREPARECOMPLEXNODE;
            if(pNode1->radius == 0)
                continue;
            if(_cvNodeMultyplicity(pSite, pEdge,pNode,LinkedEdges,LinkedSites) == 1)
                goto PREPARESIMPLENODE;
        }
// treate triangle or regular polygon
        _CV_INITIALIZE_CVLCMDATA(&LCMdata,pSite,pEdge,CV_VORONOIEDGE2D_ENDNODE(pEdge,pSite));
        if(!_cvTreatExeptionalCase(LCM,&LCMdata))
            return 0;
        continue;

PREPARECOMPLEXNODE:
        _CV_INITIALIZE_CVLCMDATA(&LCMdata,pSite,pEdge,CV_VORONOIEDGE2D_ENDNODE(pEdge,pSite));
        if(!_cvConstructLCMComplexNode(LCM,NULL,&LCMdata))
            return 0;
        continue;

PREPARESIMPLENODE:
        _CV_INITIALIZE_CVLCMDATA(&LCMdata,pSite,pEdge,CV_VORONOIEDGE2D_ENDNODE(pEdge,pSite));
        if(!_cvConstructLCMSimpleNode(LCM,NULL,&LCMdata))
            return 0;
        continue;
    }
    return 1;
}//end of _cvConstructLCM

CvLCMNode* _cvConstructLCMComplexNode(CvLCM* pLCM,
                                      CvLCMEdge* pLCMEdge,
                                      CvLCMData* pLCMInputData)
{
    CvLCMNode* pLCMNode;
    CvLCMEdge* pLCMEdge_prev = NULL;
    CvSeqWriter writer;
    CvVoronoiSite2D* pSite, *pSite_first, *pSite_last;
    CvVoronoiEdge2D* pEdge, *pEdge_stop;
    CvVoronoiNode2D* pNode0, *pNode1;
    CvLCMData LCMOutputData;
    CvLCMComplexNodeData LCMCCNData;
    int index = 0;

    _cvPrepareData(&LCMCCNData,pLCMInputData);

    pLCMNode = _cvCreateLCMNode(pLCM);
    _cvAttachLCMEdgeToLCMNode(pLCMNode,pLCMEdge,pLCMEdge_prev,1,1);
    cvStartAppendToSeq((CvSeq*)pLCMNode->contour,&writer);
    CV_WRITE_SEQ_ELEM(LCMCCNData.site_last_pt, writer);
    index++;

    if(pLCMEdge)
    {
        CV_WRITE_SEQ_ELEM(LCMCCNData.edge_node.pt, writer );
        CV_WRITE_SEQ_ELEM(LCMCCNData.site_first_pt, writer );
        index+=2;
    }

    pSite_first = LCMCCNData.site_first;
    pSite_last = LCMCCNData.site_last;
    pEdge = LCMCCNData.edge;

    for(pSite = pSite_first;
        pSite != pSite_last;
        pSite = CV_NEXT_VORONOISITE2D(pSite),
        pEdge = CV_PREV_VORONOIEDGE2D(CV_LAST_VORONOIEDGE2D(pSite),pSite))
    {
        pEdge_stop = CV_FIRST_VORONOIEDGE2D(pSite);
        for(;pEdge && pEdge != pEdge_stop;
             pEdge = CV_PREV_VORONOIEDGE2D(pEdge,pSite))
        {
            pNode0 = CV_VORONOIEDGE2D_BEGINNODE(pEdge,pSite);
            pNode1 = CV_VORONOIEDGE2D_ENDNODE(pEdge,pSite);
            if(pNode0->radius <= pLCM->maxWidth && pNode1->radius <= pLCM->maxWidth)
            {
                _CV_INITIALIZE_CVLCMDATA(&LCMOutputData,pSite,pEdge,pNode1);
                _cvPrepareData(&LCMCCNData,&LCMOutputData);
                CV_WRITE_SEQ_ELEM(LCMCCNData.site_first_pt, writer);
                CV_WRITE_SEQ_ELEM(LCMCCNData.edge_node.pt, writer );
                index+=2;
                pLCMEdge = _cvConstructLCMEdge(pLCM,&LCMOutputData);
                _cvAttachLCMEdgeToLCMNode(pLCMNode,pLCMEdge,pLCMEdge_prev,index - 1,0);
                CV_WRITE_SEQ_ELEM(LCMCCNData.site_last_pt, writer);
                index++;

                pSite = CV_TWIN_VORONOISITE2D(pSite,pEdge);
                pEdge_stop = CV_FIRST_VORONOIEDGE2D(pSite);
                if(pSite == pSite_last)
                    break;
            }
        }
        if(pSite == pSite_last)
            break;

        CV_WRITE_SEQ_ELEM(pSite->node[1]->pt, writer);
        index++;
    }

    if(pLCMEdge_prev)
        pLCMEdge_prev->next[(pLCMEdge_prev == (CvLCMEdge*)pLCMNode->first)] = pLCMNode->first;
    cvEndWriteSeq(&writer);
    return pLCMNode;
}//end of _cvConstructLCMComplexNode

CvLCMNode* _cvConstructLCMSimpleNode(CvLCM* pLCM,
                                     CvLCMEdge* pLCMEdge,
                                     CvLCMData* pLCMInputData)
{
    CvVoronoiEdge2D* pEdge = pLCMInputData->pedge;
    CvVoronoiSite2D* pSite = pLCMInputData->psite;
    CvVoronoiNode2D* pNode = CV_VORONOIEDGE2D_BEGINNODE(pEdge,pSite);

    CvVoronoiEdge2D* LinkedEdges[10];
    CvVoronoiSite2D* LinkedSites[10];
    int multyplicity = _cvNodeMultyplicity(pSite,pEdge,pNode,LinkedEdges,LinkedSites);
    if(multyplicity == 2)
    {
        pLCMInputData->pedge = LinkedEdges[1];
        pLCMInputData->psite = CV_TWIN_VORONOISITE2D(LinkedSites[1],LinkedEdges[1]);
        return NULL;
    }

    CvLCMEdge* pLCMEdge_prev = NULL;
    CvLCMNode* pLCMNode;
    CvLCMData LCMOutputData;

    pLCMNode = _cvCreateLCMNode(pLCM);
    cvSeqPush((CvSeq*)pLCMNode->contour,&pNode->pt);
    _cvAttachLCMEdgeToLCMNode(pLCMNode,pLCMEdge,pLCMEdge_prev,0,1);

    for(int i = (int)(pLCMEdge != NULL);i < multyplicity; i++)
    {
        pEdge = LinkedEdges[i];
        pSite = LinkedSites[i];
        _CV_INITIALIZE_CVLCMDATA(&LCMOutputData,CV_TWIN_VORONOISITE2D(pSite,pEdge),pEdge,pNode);
        pLCMEdge = _cvConstructLCMEdge(pLCM,&LCMOutputData);
        _cvAttachLCMEdgeToLCMNode(pLCMNode,pLCMEdge,pLCMEdge_prev,0,0);
    }
    pLCMEdge_prev->next[(pLCMEdge_prev == (CvLCMEdge*)pLCMNode->first)] = pLCMNode->first;
    return pLCMNode;
}//end of _cvConstructLCMSimpleNode

CvLCMEdge* _cvConstructLCMEdge(CvLCM* pLCM,
                               CvLCMData* pLCMInputData)
{
    CvVoronoiEdge2D* pEdge = pLCMInputData->pedge;
    CvVoronoiSite2D* pSite = pLCMInputData->psite;
    float width = 0;

    CvLCMData LCMData;
    CvVoronoiNode2D* pNode0,*pNode1;

    CvLCMEdge* pLCMEdge = _cvCreateLCMEdge(pLCM);

    CvSeqWriter writer;
    cvStartAppendToSeq(pLCMEdge->chain,&writer );

    pNode0 = pNode1 = pLCMInputData->pnode;
    CV_WRITE_SEQ_ELEM(pNode0->pt, writer);
    width += pNode0->radius;

    for(int counter = 0;
            counter < pLCM->VoronoiDiagram->edges->total;
            counter++)
    {
        pNode1 = CV_VORONOIEDGE2D_BEGINNODE(pEdge,pSite);
        if(pNode1->radius >= pLCM->maxWidth)
            goto CREATECOMPLEXNODE;

        CV_WRITE_SEQ_ELEM(pNode1->pt,writer);
        width += pNode1->radius;
        _CV_INITIALIZE_CVLCMDATA(&LCMData,pSite,pEdge,pNode1);
        if(_cvConstructLCMSimpleNode(pLCM,pLCMEdge,&LCMData))
            goto LCMEDGEEXIT;

        pEdge = LCMData.pedge; pSite = LCMData.psite;
        pNode0 = pNode1;
    }
    return NULL;

CREATECOMPLEXNODE:
    _CV_INITIALIZE_CVLCMDATA(&LCMData,pSite,pEdge,pNode0);
    CV_WRITE_SEQ_ELEM(LCMData.pnode->pt,writer);
    width += LCMData.pnode->radius;
    _cvConstructLCMComplexNode(pLCM,pLCMEdge,&LCMData);

LCMEDGEEXIT:
    cvEndWriteSeq(&writer);
    pLCMEdge->width = width/pLCMEdge->chain->total;
    return pLCMEdge;
}//end of _cvConstructLCMEdge

CvLCMNode* _cvTreatExeptionalCase(CvLCM* pLCM,
                                  CvLCMData* pLCMInputData)
{
    CvVoronoiEdge2D* pEdge = pLCMInputData->pedge;
    CvVoronoiSite2D* pSite = pLCMInputData->psite;
    CvVoronoiNode2D* pNode = CV_VORONOIEDGE2D_BEGINNODE(pEdge,pSite);
    CvLCMNode* pLCMNode = _cvCreateLCMNode(pLCM);
    cvSeqPush((CvSeq*)pLCMNode->contour,&pNode->pt);
    return pLCMNode;
}//end of _cvConstructLCMEdge

CV_INLINE
CvLCMNode* _cvCreateLCMNode(CvLCM* pLCM)
{
    CvLCMNode* pLCMNode;
    cvSetAdd((CvSet*)pLCM->Graph, NULL, (CvSetElem**)&pLCMNode );
    pLCMNode->contour = (CvContour*)cvCreateSeq(0, sizeof(CvContour),
                                                   sizeof(CvPoint2D32f),pLCM->ContourStorage);
    pLCMNode->first = NULL;
    return pLCMNode;
}//end of _cvCreateLCMNode

CV_INLINE
CvLCMEdge* _cvCreateLCMEdge(CvLCM* pLCM)
{
    CvLCMEdge* pLCMEdge;
    cvSetAdd( (CvSet*)(pLCM->Graph->edges), 0, (CvSetElem**)&pLCMEdge );
    pLCMEdge->chain = cvCreateSeq(0, sizeof(CvSeq),sizeof(CvPoint2D32f),pLCM->EdgeStorage);
    pLCMEdge->next[0] = pLCMEdge->next[1] = NULL;
    pLCMEdge->vtx[0] =  pLCMEdge->vtx[1] = NULL;
    pLCMEdge->index1 =  pLCMEdge->index2 = -1;
    return pLCMEdge;
}//end of _cvCreateLCMEdge

CV_INLINE
void _cvAttachLCMEdgeToLCMNode(CvLCMNode* LCMNode,
                               CvLCMEdge* LCMEdge,
                               CvLCMEdge* &LCMEdge_prev,
                               int index,
                               int i)
{
    if(!LCMEdge)
        return;
    if(i==0)
        LCMEdge->index1 = index;
    else
        LCMEdge->index2 = index;

    LCMEdge->vtx[i] = (CvGraphVtx*)LCMNode;
    if(!LCMEdge_prev)
        LCMNode->first = (CvGraphEdge*)LCMEdge;
    else
//      LCMEdge_prev->next[(LCMEdge_prev == (CvLCMEdge*)LCMNode->first)] = (CvGraphEdge*)LCMEdge;
        LCMEdge_prev->next[(LCMEdge_prev->vtx[0] != (CvGraphVtx*)LCMNode)] = (CvGraphEdge*)LCMEdge;

    LCMEdge->next[i] = LCMNode->first;
    LCMEdge_prev = LCMEdge;
}//end of _cvAttachLCMEdgeToLCMNode


int _cvNodeMultyplicity(CvVoronoiSite2D* pSite,
                        CvVoronoiEdge2D* pEdge,
                        CvVoronoiNode2D* pNode,
                        CvVoronoiEdge2D** LinkedEdges,
                        CvVoronoiSite2D** LinkedSites)
{
    if(!pNode->radius)
        return -1;
    assert(pNode == CV_VORONOIEDGE2D_BEGINNODE(pEdge,pSite));

    int multyplicity = 0;
    CvVoronoiEdge2D* pEdge_cur = pEdge;
    do
    {
        if(pEdge_cur->node[0]->radius && pEdge_cur->node[1]->radius)
        {
            LinkedEdges[multyplicity] = pEdge_cur;
            LinkedSites[multyplicity] = pSite;
            multyplicity++;
        }
        pEdge_cur = CV_PREV_VORONOIEDGE2D(pEdge_cur,pSite);
        pSite = CV_TWIN_VORONOISITE2D(pSite,pEdge_cur);
    }while(pEdge_cur != pEdge);
    return multyplicity;
}//end of _cvNodeMultyplicity


CV_INLINE
void _cvPrepareData(CvLCMComplexNodeData* pLCMCCNData,
                    CvLCMData* pLCMData)
{
    pLCMCCNData->site_first = pLCMData->psite;
    pLCMCCNData->site_last = CV_TWIN_VORONOISITE2D(pLCMData->psite,pLCMData->pedge);
    if(pLCMData->pedge == CV_LAST_VORONOIEDGE2D(pLCMData->psite))
    {
        pLCMCCNData->edge = CV_PREV_VORONOIEDGE2D(pLCMData->pedge,pLCMData->psite);
        pLCMCCNData->edge_node = *pLCMData->pnode;
        pLCMCCNData->site_first_pt = pLCMData->psite->node[0]->pt;
        pLCMCCNData->site_last_pt = pLCMData->psite->node[0]->pt;
    }
    else
    {
        pLCMCCNData->edge = pLCMData->pedge;
        pLCMCCNData->edge_node = *pLCMData->pnode;
        _cvProjectionPointToSegment(&pLCMCCNData->edge_node.pt,
                                  &pLCMCCNData->site_first->node[0]->pt,
                                  &pLCMCCNData->site_first->node[1]->pt,
                                  &pLCMCCNData->site_first_pt,
                                  NULL);
        _cvProjectionPointToSegment(&pLCMCCNData->edge_node.pt,
                                  &pLCMCCNData->site_last->node[0]->pt,
                                  &pLCMCCNData->site_last->node[1]->pt,
                                  &pLCMCCNData->site_last_pt,
                                  NULL);
    }
}//end of _cvPrepareData


void _cvProjectionPointToSegment(CvPoint2D32f* PointO,
                                 CvPoint2D32f* PointA,
                                 CvPoint2D32f* PointB,
                                 CvPoint2D32f* PrPoint,
                                 float* dist)
{
    float scal_AO_AB, scal_AB_AB;
    CvPoint2D32f VectorAB = {PointB->x - PointA->x, PointB->y - PointA->y};
    scal_AB_AB = VectorAB.x*VectorAB.x + VectorAB.y*VectorAB.y;
    if(scal_AB_AB < LCM_CONST_ZERO)
    {
        *PrPoint = *PointA;
        if(dist)
            *dist = (float)sqrt( (double)(PointO->x -PointA->x)*(PointO->x -PointA->x) + (PointO->y - PointA->y)*(PointO->y - PointA->y));
        return;
    }

    CvPoint2D32f VectorAO = {PointO->x - PointA->x, PointO->y - PointA->y};
    scal_AO_AB = VectorAO.x*VectorAB.x + VectorAO.y*VectorAB.y;

    if(dist)
    {
        float vector_AO_AB = (float)fabs(VectorAO.x*VectorAB.y - VectorAO.y*VectorAB.x);
        *dist = (float)(vector_AO_AB/sqrt((double)scal_AB_AB));
    }

    float alfa = scal_AO_AB/scal_AB_AB;
    PrPoint->x = PointO->x - VectorAO.x + alfa*VectorAB.x;
    PrPoint->y = PointO->y - VectorAO.y + alfa*VectorAB.y;
    return;
}//end of _cvProjectionPointToSegment