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