{"action":"created","comment":{"url":"https://api.github.com/repos/fossasia/phimpme-android/pulls/comments/178462489","pull_request_review_id":108522817,"id":178462489,"diff_hunk":"@@ -0,0 +1,3436 @@\n+/*M///////////////////////////////////////////////////////////////////////////////////////\n+//\n+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.\n+//\n+//  By downloading, copying, installing or using the software you agree to this license.\n+//  If you do not agree to this license, do not download, install,\n+//  copy or use the software.\n+//\n+//\n+//                        Intel License Agreement\n+//                For Open Source Computer Vision Library\n+//\n+// Copyright (C) 2000, Intel Corporation, all rights reserved.\n+// Third party copyrights are property of their respective owners.\n+//\n+// Redistribution and use in source and binary forms, with or without modification,\n+// are permitted provided that the following conditions are met:\n+//\n+//   * Redistribution's of source code must retain the above copyright notice,\n+//     this list of conditions and the following disclaimer.\n+//\n+//   * Redistribution's in binary form must reproduce the above copyright notice,\n+//     this list of conditions and the following disclaimer in the documentation\n+//     and/or other materials provided with the distribution.\n+//\n+//   * The name of Intel Corporation may not be used to endorse or promote products\n+//     derived from this software without specific prior written permission.\n+//\n+// This software is provided by the copyright holders and contributors \"as is\" and\n+// any express or implied warranties, including, but not limited to, the implied\n+// warranties of merchantability and fitness for a particular purpose are disclaimed.\n+// In no event shall the Intel Corporation or contributors be liable for any direct,\n+// indirect, incidental, special, exemplary, or consequential damages\n+// (including, but not limited to, procurement of substitute goods or services;\n+// loss of use, data, or profits; or business interruption) however caused\n+// and on any theory of liability, whether in contract, strict liability,\n+// or tort (including negligence or otherwise) arising in any way out of\n+// the use of this software, even if advised of the possibility of such damage.\n+//\n+//M*/\n+\n+#ifndef __OPENCV_LEGACY_HPP__\n+#define __OPENCV_LEGACY_HPP__\n+\n+#include \"opencv2/imgproc/imgproc.hpp\"\n+#include \"opencv2/imgproc/imgproc_c.h\"\n+#include \"opencv2/features2d/features2d.hpp\"\n+#include \"opencv2/calib3d/calib3d.hpp\"\n+#include \"opencv2/ml/ml.hpp\"\n+\n+#ifdef __cplusplus\n+extern \"C\" {\n+#endif\n+\n+CVAPI(CvSeq*) cvSegmentImage( const CvArr* srcarr, CvArr* dstarr,\n+                                    double canny_threshold,\n+                                    double ffill_threshold,\n+                                    CvMemStorage* storage );\n+\n+/****************************************************************************************\\\n+*                                  Eigen objects                                         *\n+\\****************************************************************************************/\n+\n+typedef int (CV_CDECL * CvCallback)(int index, void* buffer, void* user_data);\n+typedef union\n+{\n+    CvCallback callback;\n+    void* data;\n+}\n+CvInput;\n+\n+#define CV_EIGOBJ_NO_CALLBACK     0\n+#define CV_EIGOBJ_INPUT_CALLBACK  1\n+#define CV_EIGOBJ_OUTPUT_CALLBACK 2\n+#define CV_EIGOBJ_BOTH_CALLBACK   3\n+\n+/* Calculates covariation matrix of a set of arrays */\n+CVAPI(void)  cvCalcCovarMatrixEx( int nObjects, void* input, int ioFlags,\n+                                  int ioBufSize, uchar* buffer, void* userData,\n+                                  IplImage* avg, float* covarMatrix );\n+\n+/* Calculates eigen values and vectors of covariation matrix of a set of\n+   arrays */\n+CVAPI(void)  cvCalcEigenObjects( int nObjects, void* input, void* output,\n+                                 int ioFlags, int ioBufSize, void* userData,\n+                                 CvTermCriteria* calcLimit, IplImage* avg,\n+                                 float* eigVals );\n+\n+/* Calculates dot product (obj - avg) * eigObj (i.e. projects image to eigen vector) */\n+CVAPI(double)  cvCalcDecompCoeff( IplImage* obj, IplImage* eigObj, IplImage* avg );\n+\n+/* Projects image to eigen space (finds all decomposion coefficients */\n+CVAPI(void)  cvEigenDecomposite( IplImage* obj, int nEigObjs, void* eigInput,\n+                                 int ioFlags, void* userData, IplImage* avg,\n+                                 float* coeffs );\n+\n+/* Projects original objects used to calculate eigen space basis to that space */\n+CVAPI(void)  cvEigenProjection( void* eigInput, int nEigObjs, int ioFlags,\n+                                void* userData, float* coeffs, IplImage* avg,\n+                                IplImage* proj );\n+\n+/****************************************************************************************\\\n+*                                       1D/2D HMM                                        *\n+\\****************************************************************************************/\n+\n+typedef struct CvImgObsInfo\n+{\n+    int obs_x;\n+    int obs_y;\n+    int obs_size;\n+    float* obs;//consequtive observations\n+\n+    int* state;/* arr of pairs superstate/state to which observation belong */\n+    int* mix;  /* number of mixture to which observation belong */\n+\n+} CvImgObsInfo;/*struct for 1 image*/\n+\n+typedef CvImgObsInfo Cv1DObsInfo;\n+\n+typedef struct CvEHMMState\n+{\n+    int num_mix;        /*number of mixtures in this state*/\n+    float* mu;          /*mean vectors corresponding to each mixture*/\n+    float* inv_var;     /* square root of inversed variances corresp. to each mixture*/\n+    float* log_var_val; /* sum of 0.5 (LN2PI + ln(variance[i]) ) for i=1,n */\n+    float* weight;      /*array of mixture weights. Summ of all weights in state is 1. */\n+\n+} CvEHMMState;\n+\n+typedef struct CvEHMM\n+{\n+    int level; /* 0 - lowest(i.e its states are real states), ..... */\n+    int num_states; /* number of HMM states */\n+    float*  transP;/*transition probab. matrices for states */\n+    float** obsProb; /* if level == 0 - array of brob matrices corresponding to hmm\n+                        if level == 1 - martix of matrices */\n+    union\n+    {\n+        CvEHMMState* state; /* if level == 0 points to real states array,\n+                               if not - points to embedded hmms */\n+        struct CvEHMM* ehmm; /* pointer to an embedded model or NULL, if it is a leaf */\n+    } u;\n+\n+} CvEHMM;\n+\n+/*CVAPI(int)  icvCreate1DHMM( CvEHMM** this_hmm,\n+                                   int state_number, int* num_mix, int obs_size );\n+\n+CVAPI(int)  icvRelease1DHMM( CvEHMM** phmm );\n+\n+CVAPI(int)  icvUniform1DSegm( Cv1DObsInfo* obs_info, CvEHMM* hmm );\n+\n+CVAPI(int)  icvInit1DMixSegm( Cv1DObsInfo** obs_info_array, int num_img, CvEHMM* hmm);\n+\n+CVAPI(int)  icvEstimate1DHMMStateParams( CvImgObsInfo** obs_info_array, int num_img, CvEHMM* hmm);\n+\n+CVAPI(int)  icvEstimate1DObsProb( CvImgObsInfo* obs_info, CvEHMM* hmm );\n+\n+CVAPI(int)  icvEstimate1DTransProb( Cv1DObsInfo** obs_info_array,\n+                                           int num_seq,\n+                                           CvEHMM* hmm );\n+\n+CVAPI(float)  icvViterbi( Cv1DObsInfo* obs_info, CvEHMM* hmm);\n+\n+CVAPI(int)  icv1DMixSegmL2( CvImgObsInfo** obs_info_array, int num_img, CvEHMM* hmm );*/\n+\n+/*********************************** Embedded HMMs *************************************/\n+\n+/* Creates 2D HMM */\n+CVAPI(CvEHMM*)  cvCreate2DHMM( int* stateNumber, int* numMix, int obsSize );\n+\n+/* Releases HMM */\n+CVAPI(void)  cvRelease2DHMM( CvEHMM** hmm );\n+\n+#define CV_COUNT_OBS(roi, win, delta, numObs )                                       \\\n+{                                                                                    \\\n+   (numObs)->width  =((roi)->width  -(win)->width  +(delta)->width)/(delta)->width;  \\\n+   (numObs)->height =((roi)->height -(win)->height +(delta)->height)/(delta)->height;\\\n+}\n+\n+/* Creates storage for observation vectors */\n+CVAPI(CvImgObsInfo*)  cvCreateObsInfo( CvSize numObs, int obsSize );\n+\n+/* Releases storage for observation vectors */\n+CVAPI(void)  cvReleaseObsInfo( CvImgObsInfo** obs_info );\n+\n+\n+/* The function takes an image on input and and returns the sequnce of observations\n+   to be used with an embedded HMM; Each observation is top-left block of DCT\n+   coefficient matrix */\n+CVAPI(void)  cvImgToObs_DCT( const CvArr* arr, float* obs, CvSize dctSize,\n+                             CvSize obsSize, CvSize delta );\n+\n+\n+/* Uniformly segments all observation vectors extracted from image */\n+CVAPI(void)  cvUniformImgSegm( CvImgObsInfo* obs_info, CvEHMM* ehmm );\n+\n+/* Does mixture segmentation of the states of embedded HMM */\n+CVAPI(void)  cvInitMixSegm( CvImgObsInfo** obs_info_array,\n+                            int num_img, CvEHMM* hmm );\n+\n+/* Function calculates means, variances, weights of every Gaussian mixture\n+   of every low-level state of embedded HMM */\n+CVAPI(void)  cvEstimateHMMStateParams( CvImgObsInfo** obs_info_array,\n+                                       int num_img, CvEHMM* hmm );\n+\n+/* Function computes transition probability matrices of embedded HMM\n+   given observations segmentation */\n+CVAPI(void)  cvEstimateTransProb( CvImgObsInfo** obs_info_array,\n+                                  int num_img, CvEHMM* hmm );\n+\n+/* Function computes probabilities of appearing observations at any state\n+   (i.e. computes P(obs|state) for every pair(obs,state)) */\n+CVAPI(void)  cvEstimateObsProb( CvImgObsInfo* obs_info,\n+                                CvEHMM* hmm );\n+\n+/* Runs Viterbi algorithm for embedded HMM */\n+CVAPI(float)  cvEViterbi( CvImgObsInfo* obs_info, CvEHMM* hmm );\n+\n+\n+/* Function clusters observation vectors from several images\n+   given observations segmentation.\n+   Euclidean distance used for clustering vectors.\n+   Centers of clusters are given means of every mixture */\n+CVAPI(void)  cvMixSegmL2( CvImgObsInfo** obs_info_array,\n+                          int num_img, CvEHMM* hmm );\n+\n+/****************************************************************************************\\\n+*               A few functions from old stereo gesture recognition demosions            *\n+\\****************************************************************************************/\n+\n+/* Creates hand mask image given several points on the hand */\n+CVAPI(void)  cvCreateHandMask( CvSeq* hand_points,\n+                                   IplImage *img_mask, CvRect *roi);\n+\n+/* Finds hand region in range image data */\n+CVAPI(void)  cvFindHandRegion (CvPoint3D32f* points, int count,\n+                                CvSeq* indexs,\n+                                float* line, CvSize2D32f size, int flag,\n+                                CvPoint3D32f* center,\n+                                CvMemStorage* storage, CvSeq **numbers);\n+\n+/* Finds hand region in range image data (advanced version) */\n+CVAPI(void)  cvFindHandRegionA( CvPoint3D32f* points, int count,\n+                                CvSeq* indexs,\n+                                float* line, CvSize2D32f size, int jc,\n+                                CvPoint3D32f* center,\n+                                CvMemStorage* storage, CvSeq **numbers);\n+\n+/* Calculates the cooficients of the homography matrix */\n+CVAPI(void)  cvCalcImageHomography( float* line, CvPoint3D32f* center,\n+                                    float* intrinsic, float* homography );\n+\n+/****************************************************************************************\\\n+*                           More operations on sequences                                 *\n+\\****************************************************************************************/\n+\n+/*****************************************************************************************/\n+\n+#define CV_CURRENT_INT( reader ) (*((int *)(reader).ptr))\n+#define CV_PREV_INT( reader ) (*((int *)(reader).prev_elem))\n+\n+#define  CV_GRAPH_WEIGHTED_VERTEX_FIELDS() CV_GRAPH_VERTEX_FIELDS()\\\n+    float weight;\n+\n+#define  CV_GRAPH_WEIGHTED_EDGE_FIELDS() CV_GRAPH_EDGE_FIELDS()\n+\n+typedef struct CvGraphWeightedVtx\n+{\n+    CV_GRAPH_WEIGHTED_VERTEX_FIELDS()\n+} CvGraphWeightedVtx;\n+\n+typedef struct CvGraphWeightedEdge\n+{\n+    CV_GRAPH_WEIGHTED_EDGE_FIELDS()\n+} CvGraphWeightedEdge;\n+\n+typedef enum CvGraphWeightType\n+{\n+    CV_NOT_WEIGHTED,\n+    CV_WEIGHTED_VTX,\n+    CV_WEIGHTED_EDGE,\n+    CV_WEIGHTED_ALL\n+} CvGraphWeightType;\n+\n+\n+/* Calculates histogram of a contour */\n+CVAPI(void)  cvCalcPGH( const CvSeq* contour, CvHistogram* hist );\n+\n+#define CV_DOMINANT_IPAN 1\n+\n+/* Finds high-curvature points of the contour */\n+CVAPI(CvSeq*) cvFindDominantPoints( CvSeq* contour, CvMemStorage* storage,\n+                                   int method CV_DEFAULT(CV_DOMINANT_IPAN),\n+                                   double parameter1 CV_DEFAULT(0),\n+                                   double parameter2 CV_DEFAULT(0),\n+                                   double parameter3 CV_DEFAULT(0),\n+                                   double parameter4 CV_DEFAULT(0));\n+\n+/*****************************************************************************************/\n+\n+\n+/*******************************Stereo correspondence*************************************/\n+\n+typedef struct CvCliqueFinder\n+{\n+    CvGraph* graph;\n+    int**    adj_matr;\n+    int N; //graph size\n+\n+    // stacks, counters etc/\n+    int k; //stack size\n+    int* current_comp;\n+    int** All;\n+\n+    int* ne;\n+    int* ce;\n+    int* fixp; //node with minimal disconnections\n+    int* nod;\n+    int* s; //for selected candidate\n+    int status;\n+    int best_score;\n+    int weighted;\n+    int weighted_edges;\n+    float best_weight;\n+    float* edge_weights;\n+    float* vertex_weights;\n+    float* cur_weight;\n+    float* cand_weight;\n+\n+} CvCliqueFinder;\n+\n+#define CLIQUE_TIME_OFF 2\n+#define CLIQUE_FOUND 1\n+#define CLIQUE_END   0\n+\n+/*CVAPI(void) cvStartFindCliques( CvGraph* graph, CvCliqueFinder* finder, int reverse,\n+                                   int weighted CV_DEFAULT(0),  int weighted_edges CV_DEFAULT(0));\n+CVAPI(int) cvFindNextMaximalClique( CvCliqueFinder* finder, int* clock_rest CV_DEFAULT(0) );\n+CVAPI(void) cvEndFindCliques( CvCliqueFinder* finder );\n+\n+CVAPI(void) cvBronKerbosch( CvGraph* graph );*/\n+\n+\n+/*F///////////////////////////////////////////////////////////////////////////////////////\n+//\n+//    Name:    cvSubgraphWeight\n+//    Purpose: finds weight of subgraph in a graph\n+//    Context:\n+//    Parameters:\n+//      graph - input graph.\n+//      subgraph - sequence of pairwise different ints.  These are indices of vertices of subgraph.\n+//      weight_type - describes the way we measure weight.\n+//            one of the following:\n+//            CV_NOT_WEIGHTED - weight of a clique is simply its size\n+//            CV_WEIGHTED_VTX - weight of a clique is the sum of weights of its vertices\n+//            CV_WEIGHTED_EDGE - the same but edges\n+//            CV_WEIGHTED_ALL - the same but both edges and vertices\n+//      weight_vtx - optional vector of floats, with size = graph->total.\n+//            If weight_type is either CV_WEIGHTED_VTX or CV_WEIGHTED_ALL\n+//            weights of vertices must be provided.  If weight_vtx not zero\n+//            these weights considered to be here, otherwise function assumes\n+//            that vertices of graph are inherited from CvGraphWeightedVtx.\n+//      weight_edge - optional matrix of floats, of width and height = graph->total.\n+//            If weight_type is either CV_WEIGHTED_EDGE or CV_WEIGHTED_ALL\n+//            weights of edges ought to be supplied.  If weight_edge is not zero\n+//            function finds them here, otherwise function expects\n+//            edges of graph to be inherited from CvGraphWeightedEdge.\n+//            If this parameter is not zero structure of the graph is determined from matrix\n+//            rather than from CvGraphEdge's.  In particular, elements corresponding to\n+//            absent edges should be zero.\n+//    Returns:\n+//      weight of subgraph.\n+//    Notes:\n+//F*/\n+/*CVAPI(float) cvSubgraphWeight( CvGraph *graph, CvSeq *subgraph,\n+                                  CvGraphWeightType weight_type CV_DEFAULT(CV_NOT_WEIGHTED),\n+                                  CvVect32f weight_vtx CV_DEFAULT(0),\n+                                  CvMatr32f weight_edge CV_DEFAULT(0) );*/\n+\n+\n+/*F///////////////////////////////////////////////////////////////////////////////////////\n+//\n+//    Name:    cvFindCliqueEx\n+//    Purpose: tries to find clique with maximum possible weight in a graph\n+//    Context:\n+//    Parameters:\n+//      graph - input graph.\n+//      storage - memory storage to be used by the result.\n+//      is_complementary - optional flag showing whether function should seek for clique\n+//            in complementary graph.\n+//      weight_type - describes our notion about weight.\n+//            one of the following:\n+//            CV_NOT_WEIGHTED - weight of a clique is simply its size\n+//            CV_WEIGHTED_VTX - weight of a clique is the sum of weights of its vertices\n+//            CV_WEIGHTED_EDGE - the same but edges\n+//            CV_WEIGHTED_ALL - the same but both edges and vertices\n+//      weight_vtx - optional vector of floats, with size = graph->total.\n+//            If weight_type is either CV_WEIGHTED_VTX or CV_WEIGHTED_ALL\n+//            weights of vertices must be provided.  If weight_vtx not zero\n+//            these weights considered to be here, otherwise function assumes\n+//            that vertices of graph are inherited from CvGraphWeightedVtx.\n+//      weight_edge - optional matrix of floats, of width and height = graph->total.\n+//            If weight_type is either CV_WEIGHTED_EDGE or CV_WEIGHTED_ALL\n+//            weights of edges ought to be supplied.  If weight_edge is not zero\n+//            function finds them here, otherwise function expects\n+//            edges of graph to be inherited from CvGraphWeightedEdge.\n+//            Note that in case of CV_WEIGHTED_EDGE or CV_WEIGHTED_ALL\n+//            nonzero is_complementary implies nonzero weight_edge.\n+//      start_clique - optional sequence of pairwise different ints.  They are indices of\n+//            vertices that shall be present in the output clique.\n+//      subgraph_of_ban - optional sequence of (maybe equal) ints.  They are indices of\n+//            vertices that shall not be present in the output clique.\n+//      clique_weight_ptr - optional output parameter.  Weight of found clique stored here.\n+//      num_generations - optional number of generations in evolutionary part of algorithm,\n+//            zero forces to return first found clique.\n+//      quality - optional parameter determining degree of required quality/speed tradeoff.\n+//            Must be in the range from 0 to 9.\n+//            0 is fast and dirty, 9 is slow but hopefully yields good clique.\n+//    Returns:\n+//      sequence of pairwise different ints.\n+//      These are indices of vertices that form found clique.\n+//    Notes:\n+//      in cases of CV_WEIGHTED_EDGE and CV_WEIGHTED_ALL weights should be nonnegative.\n+//      start_clique has a priority over subgraph_of_ban.\n+//F*/\n+/*CVAPI(CvSeq*) cvFindCliqueEx( CvGraph *graph, CvMemStorage *storage,\n+                                 int is_complementary CV_DEFAULT(0),\n+                                 CvGraphWeightType weight_type CV_DEFAULT(CV_NOT_WEIGHTED),\n+                                 CvVect32f weight_vtx CV_DEFAULT(0),\n+                                 CvMatr32f weight_edge CV_DEFAULT(0),\n+                                 CvSeq *start_clique CV_DEFAULT(0),\n+                                 CvSeq *subgraph_of_ban CV_DEFAULT(0),\n+                                 float *clique_weight_ptr CV_DEFAULT(0),\n+                                 int num_generations CV_DEFAULT(3),\n+                                 int quality CV_DEFAULT(2) );*/\n+\n+\n+#define CV_UNDEF_SC_PARAM         12345 //default value of parameters\n+\n+#define CV_IDP_BIRCHFIELD_PARAM1  25\n+#define CV_IDP_BIRCHFIELD_PARAM2  5\n+#define CV_IDP_BIRCHFIELD_PARAM3  12\n+#define CV_IDP_BIRCHFIELD_PARAM4  15\n+#define CV_IDP_BIRCHFIELD_PARAM5  25\n+\n+\n+#define  CV_DISPARITY_BIRCHFIELD  0\n+\n+\n+/*F///////////////////////////////////////////////////////////////////////////\n+//\n+//    Name:    cvFindStereoCorrespondence\n+//    Purpose: find stereo correspondence on stereo-pair\n+//    Context:\n+//    Parameters:\n+//      leftImage - left image of stereo-pair (format 8uC1).\n+//      rightImage - right image of stereo-pair (format 8uC1).\n+//   mode - mode of correspondence retrieval (now CV_DISPARITY_BIRCHFIELD only)\n+//      dispImage - destination disparity image\n+//      maxDisparity - maximal disparity\n+//      param1, param2, param3, param4, param5 - parameters of algorithm\n+//    Returns:\n+//    Notes:\n+//      Images must be rectified.\n+//      All images must have format 8uC1.\n+//F*/\n+CVAPI(void)\n+cvFindStereoCorrespondence(\n+                   const  CvArr* leftImage, const  CvArr* rightImage,\n+                   int     mode,\n+                   CvArr*  dispImage,\n+                   int     maxDisparity,\n+                   double  param1 CV_DEFAULT(CV_UNDEF_SC_PARAM),\n+                   double  param2 CV_DEFAULT(CV_UNDEF_SC_PARAM),\n+                   double  param3 CV_DEFAULT(CV_UNDEF_SC_PARAM),\n+                   double  param4 CV_DEFAULT(CV_UNDEF_SC_PARAM),\n+                   double  param5 CV_DEFAULT(CV_UNDEF_SC_PARAM) );\n+\n+/*****************************************************************************************/\n+/************ Epiline functions *******************/\n+\n+\n+\n+typedef struct CvStereoLineCoeff\n+{\n+    double Xcoef;\n+    double XcoefA;\n+    double XcoefB;\n+    double XcoefAB;\n+\n+    double Ycoef;\n+    double YcoefA;\n+    double YcoefB;\n+    double YcoefAB;\n+\n+    double Zcoef;\n+    double ZcoefA;\n+    double ZcoefB;\n+    double ZcoefAB;\n+}CvStereoLineCoeff;\n+\n+\n+typedef struct CvCamera\n+{\n+    float   imgSize[2]; /* size of the camera view, used during calibration */\n+    float   matrix[9]; /* intinsic camera parameters:  [ fx 0 cx; 0 fy cy; 0 0 1 ] */\n+    float   distortion[4]; /* distortion coefficients - two coefficients for radial distortion\n+                              and another two for tangential: [ k1 k2 p1 p2 ] */\n+    float   rotMatr[9];\n+    float   transVect[3]; /* rotation matrix and transition vector relatively\n+                             to some reference point in the space. */\n+} CvCamera;\n+\n+typedef struct CvStereoCamera\n+{\n+    CvCamera* camera[2]; /* two individual camera parameters */\n+    float fundMatr[9]; /* fundamental matrix */\n+\n+    /* New part for stereo */\n+    CvPoint3D32f epipole[2];\n+    CvPoint2D32f quad[2][4]; /* coordinates of destination quadrangle after\n+                                epipolar geometry rectification */\n+    double coeffs[2][3][3];/* coefficients for transformation */\n+    CvPoint2D32f border[2][4];\n+    CvSize warpSize;\n+    CvStereoLineCoeff* lineCoeffs;\n+    int needSwapCameras;/* flag set to 1 if need to swap cameras for good reconstruction */\n+    float rotMatrix[9];\n+    float transVector[3];\n+} CvStereoCamera;\n+\n+\n+typedef struct CvContourOrientation\n+{\n+    float egvals[2];\n+    float egvects[4];\n+\n+    float max, min; // minimum and maximum projections\n+    int imax, imin;\n+} CvContourOrientation;\n+\n+#define CV_CAMERA_TO_WARP 1\n+#define CV_WARP_TO_CAMERA 2\n+\n+CVAPI(int) icvConvertWarpCoordinates(double coeffs[3][3],\n+                                CvPoint2D32f* cameraPoint,\n+                                CvPoint2D32f* warpPoint,\n+                                int direction);\n+\n+CVAPI(int) icvGetSymPoint3D(  CvPoint3D64f pointCorner,\n+                            CvPoint3D64f point1,\n+                            CvPoint3D64f point2,\n+                            CvPoint3D64f *pointSym2);\n+\n+CVAPI(void) icvGetPieceLength3D(CvPoint3D64f point1,CvPoint3D64f point2,double* dist);\n+\n+CVAPI(int) icvCompute3DPoint(    double alpha,double betta,\n+                            CvStereoLineCoeff* coeffs,\n+                            CvPoint3D64f* point);\n+\n+CVAPI(int) icvCreateConvertMatrVect( double*     rotMatr1,\n+                                double*     transVect1,\n+                                double*     rotMatr2,\n+                                double*     transVect2,\n+                                double*     convRotMatr,\n+                                double*     convTransVect);\n+\n+CVAPI(int) icvConvertPointSystem(CvPoint3D64f  M2,\n+                            CvPoint3D64f* M1,\n+                            double*     rotMatr,\n+                            double*     transVect\n+                            );\n+\n+CVAPI(int) icvComputeCoeffForStereo(  CvStereoCamera* stereoCamera);\n+\n+CVAPI(int) icvGetCrossPieceVector(CvPoint2D32f p1_start,CvPoint2D32f p1_end,CvPoint2D32f v2_start,CvPoint2D32f v2_end,CvPoint2D32f *cross);\n+CVAPI(int) icvGetCrossLineDirect(CvPoint2D32f p1,CvPoint2D32f p2,float a,float b,float c,CvPoint2D32f* cross);\n+CVAPI(float) icvDefinePointPosition(CvPoint2D32f point1,CvPoint2D32f point2,CvPoint2D32f point);\n+CVAPI(int) icvStereoCalibration( int numImages,\n+                            int* nums,\n+                            CvSize imageSize,\n+                            CvPoint2D32f* imagePoints1,\n+                            CvPoint2D32f* imagePoints2,\n+                            CvPoint3D32f* objectPoints,\n+                            CvStereoCamera* stereoparams\n+                           );\n+\n+\n+CVAPI(int) icvComputeRestStereoParams(CvStereoCamera *stereoparams);\n+\n+CVAPI(void) cvComputePerspectiveMap( const double coeffs[3][3], CvArr* rectMapX, CvArr* rectMapY );\n+\n+CVAPI(int) icvComCoeffForLine(   CvPoint2D64f point1,\n+                            CvPoint2D64f point2,\n+                            CvPoint2D64f point3,\n+                            CvPoint2D64f point4,\n+                            double*    camMatr1,\n+                            double*    rotMatr1,\n+                            double*    transVect1,\n+                            double*    camMatr2,\n+                            double*    rotMatr2,\n+                            double*    transVect2,\n+                            CvStereoLineCoeff*    coeffs,\n+                            int* needSwapCameras);\n+\n+CVAPI(int) icvGetDirectionForPoint(  CvPoint2D64f point,\n+                                double* camMatr,\n+                                CvPoint3D64f* direct);\n+\n+CVAPI(int) icvGetCrossLines(CvPoint3D64f point11,CvPoint3D64f point12,\n+                       CvPoint3D64f point21,CvPoint3D64f point22,\n+                       CvPoint3D64f* midPoint);\n+\n+CVAPI(int) icvComputeStereoLineCoeffs(   CvPoint3D64f pointA,\n+                                    CvPoint3D64f pointB,\n+                                    CvPoint3D64f pointCam1,\n+                                    double gamma,\n+                                    CvStereoLineCoeff*    coeffs);\n+\n+/*CVAPI(int) icvComputeFundMatrEpipoles ( double* camMatr1,\n+                                    double*     rotMatr1,\n+                                    double*     transVect1,\n+                                    double*     camMatr2,\n+                                    double*     rotMatr2,\n+                                    double*     transVect2,\n+                                    CvPoint2D64f* epipole1,\n+                                    CvPoint2D64f* epipole2,\n+                                    double*     fundMatr);*/\n+\n+CVAPI(int) icvGetAngleLine( CvPoint2D64f startPoint, CvSize imageSize,CvPoint2D64f *point1,CvPoint2D64f *point2);\n+\n+CVAPI(void) icvGetCoefForPiece(   CvPoint2D64f p_start,CvPoint2D64f p_end,\n+                        double *a,double *b,double *c,\n+                        int* result);\n+\n+/*CVAPI(void) icvGetCommonArea( CvSize imageSize,\n+                    CvPoint2D64f epipole1,CvPoint2D64f epipole2,\n+                    double* fundMatr,\n+                    double* coeff11,double* coeff12,\n+                    double* coeff21,double* coeff22,\n+                    int* result);*/\n+\n+CVAPI(void) icvComputeeInfiniteProject1(double*    rotMatr,\n+                                     double*    camMatr1,\n+                                     double*    camMatr2,\n+                                     CvPoint2D32f point1,\n+                                     CvPoint2D32f *point2);\n+\n+CVAPI(void) icvComputeeInfiniteProject2(double*    rotMatr,\n+                                     double*    camMatr1,\n+                                     double*    camMatr2,\n+                                     CvPoint2D32f* point1,\n+                                     CvPoint2D32f point2);\n+\n+CVAPI(void) icvGetCrossDirectDirect(  double* direct1,double* direct2,\n+                            CvPoint2D64f *cross,int* result);\n+\n+CVAPI(void) icvGetCrossPieceDirect(   CvPoint2D64f p_start,CvPoint2D64f p_end,\n+                            double a,double b,double c,\n+                            CvPoint2D64f *cross,int* result);\n+\n+CVAPI(void) icvGetCrossPiecePiece( CvPoint2D64f p1_start,CvPoint2D64f p1_end,\n+                            CvPoint2D64f p2_start,CvPoint2D64f p2_end,\n+                            CvPoint2D64f* cross,\n+                            int* result);\n+\n+CVAPI(void) icvGetPieceLength(CvPoint2D64f point1,CvPoint2D64f point2,double* dist);\n+\n+CVAPI(void) icvGetCrossRectDirect(    CvSize imageSize,\n+                            double a,double b,double c,\n+                            CvPoint2D64f *start,CvPoint2D64f *end,\n+                            int* result);\n+\n+CVAPI(void) icvProjectPointToImage(   CvPoint3D64f point,\n+                            double* camMatr,double* rotMatr,double* transVect,\n+                            CvPoint2D64f* projPoint);\n+\n+CVAPI(void) icvGetQuadsTransform( CvSize        imageSize,\n+                        double*     camMatr1,\n+                        double*     rotMatr1,\n+                        double*     transVect1,\n+                        double*     camMatr2,\n+                        double*     rotMatr2,\n+                        double*     transVect2,\n+                        CvSize*       warpSize,\n+                        double quad1[4][2],\n+                        double quad2[4][2],\n+                        double*     fundMatr,\n+                        CvPoint3D64f* epipole1,\n+                        CvPoint3D64f* epipole2\n+                        );\n+\n+CVAPI(void) icvGetQuadsTransformStruct(  CvStereoCamera* stereoCamera);\n+\n+CVAPI(void) icvComputeStereoParamsForCameras(CvStereoCamera* stereoCamera);\n+\n+CVAPI(void) icvGetCutPiece(   double* areaLineCoef1,double* areaLineCoef2,\n+                    CvPoint2D64f epipole,\n+                    CvSize imageSize,\n+                    CvPoint2D64f* point11,CvPoint2D64f* point12,\n+                    CvPoint2D64f* point21,CvPoint2D64f* point22,\n+                    int* result);\n+\n+CVAPI(void) icvGetMiddleAnglePoint(   CvPoint2D64f basePoint,\n+                            CvPoint2D64f point1,CvPoint2D64f point2,\n+                            CvPoint2D64f* midPoint);\n+\n+CVAPI(void) icvGetNormalDirect(double* direct,CvPoint2D64f point,double* normDirect);\n+\n+CVAPI(double) icvGetVect(CvPoint2D64f basePoint,CvPoint2D64f point1,CvPoint2D64f point2);\n+\n+CVAPI(void) icvProjectPointToDirect(  CvPoint2D64f point,double* lineCoeff,\n+                            CvPoint2D64f* projectPoint);\n+\n+CVAPI(void) icvGetDistanceFromPointToDirect( CvPoint2D64f point,double* lineCoef,double*dist);\n+\n+CVAPI(IplImage*) icvCreateIsometricImage( IplImage* src, IplImage* dst,\n+                              int desired_depth, int desired_num_channels );\n+\n+CVAPI(void) cvDeInterlace( const CvArr* frame, CvArr* fieldEven, CvArr* fieldOdd );\n+\n+/*CVAPI(int) icvSelectBestRt(           int           numImages,\n+                                    int*          numPoints,\n+                                    CvSize        imageSize,\n+                                    CvPoint2D32f* imagePoints1,\n+                                    CvPoint2D32f* imagePoints2,\n+                                    CvPoint3D32f* objectPoints,\n+\n+                                    CvMatr32f     cameraMatrix1,\n+                                    CvVect32f     distortion1,\n+                                    CvMatr32f     rotMatrs1,\n+                                    CvVect32f     transVects1,\n+\n+                                    CvMatr32f     cameraMatrix2,\n+                                    CvVect32f     distortion2,\n+                                    CvMatr32f     rotMatrs2,\n+                                    CvVect32f     transVects2,\n+\n+                                    CvMatr32f     bestRotMatr,\n+                                    CvVect32f     bestTransVect\n+                                    );*/\n+\n+\n+/****************************************************************************************\\\n+*                                     Contour Tree                                       *\n+\\****************************************************************************************/\n+\n+/* Contour tree header */\n+typedef struct CvContourTree\n+{\n+    CV_SEQUENCE_FIELDS()\n+    CvPoint p1;            /* the first point of the binary tree root segment */\n+    CvPoint p2;            /* the last point of the binary tree root segment */\n+} CvContourTree;\n+\n+/* Builds hierarhical representation of a contour */\n+CVAPI(CvContourTree*)  cvCreateContourTree( const CvSeq* contour,\n+                                            CvMemStorage* storage,\n+                                            double threshold );\n+\n+/* Reconstruct (completelly or partially) contour a from contour tree */\n+CVAPI(CvSeq*)  cvContourFromContourTree( const CvContourTree* tree,\n+                                         CvMemStorage* storage,\n+                                         CvTermCriteria criteria );\n+\n+/* Compares two contour trees */\n+enum { CV_CONTOUR_TREES_MATCH_I1 = 1 };\n+\n+CVAPI(double)  cvMatchContourTrees( const CvContourTree* tree1,\n+                                    const CvContourTree* tree2,\n+                                    int method, double threshold );\n+\n+/****************************************************************************************\\\n+*                                   Contour Morphing                                     *\n+\\****************************************************************************************/\n+\n+/* finds correspondence between two contours */\n+CvSeq* cvCalcContoursCorrespondence( const CvSeq* contour1,\n+                                     const CvSeq* contour2,\n+                                     CvMemStorage* storage);\n+\n+/* morphs contours using the pre-calculated correspondence:\n+   alpha=0 ~ contour1, alpha=1 ~ contour2 */\n+CvSeq* cvMorphContours( const CvSeq* contour1, const CvSeq* contour2,\n+                        CvSeq* corr, double alpha,\n+                        CvMemStorage* storage );\n+\n+\n+/****************************************************************************************\\\n+*                                   Active Contours                                      *\n+\\****************************************************************************************/\n+\n+#define  CV_VALUE  1\n+#define  CV_ARRAY  2\n+/* Updates active contour in order to minimize its cummulative\n+   (internal and external) energy. */\n+CVAPI(void)  cvSnakeImage( const IplImage* image, CvPoint* points,\n+                           int  length, float* alpha,\n+                           float* beta, float* gamma,\n+                           int coeff_usage, CvSize  win,\n+                           CvTermCriteria criteria, int calc_gradient CV_DEFAULT(1));\n+\n+/****************************************************************************************\\\n+*                                    Texture Descriptors                                 *\n+\\****************************************************************************************/\n+\n+#define CV_GLCM_OPTIMIZATION_NONE                   -2\n+#define CV_GLCM_OPTIMIZATION_LUT                    -1\n+#define CV_GLCM_OPTIMIZATION_HISTOGRAM              0\n+\n+#define CV_GLCMDESC_OPTIMIZATION_ALLOWDOUBLENEST    10\n+#define CV_GLCMDESC_OPTIMIZATION_ALLOWTRIPLENEST    11\n+#define CV_GLCMDESC_OPTIMIZATION_HISTOGRAM          4\n+\n+#define CV_GLCMDESC_ENTROPY                         0\n+#define CV_GLCMDESC_ENERGY                          1\n+#define CV_GLCMDESC_HOMOGENITY                      2\n+#define CV_GLCMDESC_CONTRAST                        3\n+#define CV_GLCMDESC_CLUSTERTENDENCY                 4\n+#define CV_GLCMDESC_CLUSTERSHADE                    5\n+#define CV_GLCMDESC_CORRELATION                     6\n+#define CV_GLCMDESC_CORRELATIONINFO1                7\n+#define CV_GLCMDESC_CORRELATIONINFO2                8\n+#define CV_GLCMDESC_MAXIMUMPROBABILITY              9\n+\n+#define CV_GLCM_ALL                                 0\n+#define CV_GLCM_GLCM                                1\n+#define CV_GLCM_DESC                                2\n+\n+typedef struct CvGLCM CvGLCM;\n+\n+CVAPI(CvGLCM*) cvCreateGLCM( const IplImage* srcImage,\n+                                int stepMagnitude,\n+                                const int* stepDirections CV_DEFAULT(0),\n+                                int numStepDirections CV_DEFAULT(0),\n+                                int optimizationType CV_DEFAULT(CV_GLCM_OPTIMIZATION_NONE));\n+\n+CVAPI(void) cvReleaseGLCM( CvGLCM** GLCM, int flag CV_DEFAULT(CV_GLCM_ALL));\n+\n+CVAPI(void) cvCreateGLCMDescriptors( CvGLCM* destGLCM,\n+                                        int descriptorOptimizationType\n+                                        CV_DEFAULT(CV_GLCMDESC_OPTIMIZATION_ALLOWDOUBLENEST));\n+\n+CVAPI(double) cvGetGLCMDescriptor( CvGLCM* GLCM, int step, int descriptor );\n+\n+CVAPI(void) cvGetGLCMDescriptorStatistics( CvGLCM* GLCM, int descriptor,\n+                                              double* average, double* standardDeviation );\n+\n+CVAPI(IplImage*) cvCreateGLCMImage( CvGLCM* GLCM, int step );\n+\n+/****************************************************************************************\\\n+*                                  Face eyes&mouth tracking                              *\n+\\****************************************************************************************/\n+\n+\n+typedef struct CvFaceTracker CvFaceTracker;\n+\n+#define CV_NUM_FACE_ELEMENTS    3\n+enum CV_FACE_ELEMENTS\n+{\n+    CV_FACE_MOUTH = 0,\n+    CV_FACE_LEFT_EYE = 1,\n+    CV_FACE_RIGHT_EYE = 2\n+};\n+\n+CVAPI(CvFaceTracker*) cvInitFaceTracker(CvFaceTracker* pFaceTracking, const IplImage* imgGray,\n+                                                CvRect* pRects, int nRects);\n+CVAPI(int) cvTrackFace( CvFaceTracker* pFaceTracker, IplImage* imgGray,\n+                              CvRect* pRects, int nRects,\n+                              CvPoint* ptRotate, double* dbAngleRotate);\n+CVAPI(void) cvReleaseFaceTracker(CvFaceTracker** ppFaceTracker);\n+\n+\n+typedef struct CvFace\n+{\n+    CvRect MouthRect;\n+    CvRect LeftEyeRect;\n+    CvRect RightEyeRect;\n+} CvFaceData;\n+\n+CvSeq * cvFindFace(IplImage * Image,CvMemStorage* storage);\n+CvSeq * cvPostBoostingFindFace(IplImage * Image,CvMemStorage* storage);\n+\n+\n+/****************************************************************************************\\\n+*                                         3D Tracker                                     *\n+\\****************************************************************************************/\n+\n+typedef unsigned char CvBool;\n+\n+typedef struct Cv3dTracker2dTrackedObject\n+{\n+    int id;\n+    CvPoint2D32f p; // pgruebele: So we do not loose precision, this needs to be float\n+} Cv3dTracker2dTrackedObject;\n+\n+CV_INLINE Cv3dTracker2dTrackedObject cv3dTracker2dTrackedObject(int id, CvPoint2D32f p)\n+{\n+    Cv3dTracker2dTrackedObject r;\n+    r.id = id;\n+    r.p = p;\n+    return r;\n+}\n+\n+typedef struct Cv3dTrackerTrackedObject\n+{\n+    int id;\n+    CvPoint3D32f p;             // location of the tracked object\n+} Cv3dTrackerTrackedObject;\n+\n+CV_INLINE Cv3dTrackerTrackedObject cv3dTrackerTrackedObject(int id, CvPoint3D32f p)\n+{\n+    Cv3dTrackerTrackedObject r;\n+    r.id = id;\n+    r.p = p;\n+    return r;\n+}\n+\n+typedef struct Cv3dTrackerCameraInfo\n+{\n+    CvBool valid;\n+    float mat[4][4];              /* maps camera coordinates to world coordinates */\n+    CvPoint2D32f principal_point; /* copied from intrinsics so this structure */\n+                                  /* has all the info we need */\n+} Cv3dTrackerCameraInfo;\n+\n+typedef struct Cv3dTrackerCameraIntrinsics\n+{\n+    CvPoint2D32f principal_point;\n+    float focal_length[2];\n+    float distortion[4];\n+} Cv3dTrackerCameraIntrinsics;\n+\n+CVAPI(CvBool) cv3dTrackerCalibrateCameras(int num_cameras,\n+                     const Cv3dTrackerCameraIntrinsics camera_intrinsics[], /* size is num_cameras */\n+                     CvSize etalon_size,\n+                     float square_size,\n+                     IplImage *samples[],                                   /* size is num_cameras */\n+                     Cv3dTrackerCameraInfo camera_info[]);                  /* size is num_cameras */\n+\n+CVAPI(int)  cv3dTrackerLocateObjects(int num_cameras, int num_objects,\n+                   const Cv3dTrackerCameraInfo camera_info[],        /* size is num_cameras */\n+                   const Cv3dTracker2dTrackedObject tracking_info[], /* size is num_objects*num_cameras */\n+                   Cv3dTrackerTrackedObject tracked_objects[]);      /* size is num_objects */\n+/****************************************************************************************\n+ tracking_info is a rectangular array; one row per camera, num_objects elements per row.\n+ The id field of any unused slots must be -1. Ids need not be ordered or consecutive. On\n+ completion, the return value is the number of objects located; i.e., the number of objects\n+ visible by more than one camera. The id field of any unused slots in tracked objects is\n+ set to -1.\n+****************************************************************************************/\n+\n+\n+/****************************************************************************************\\\n+*                           Skeletons and Linear-Contour Models                          *\n+\\****************************************************************************************/\n+\n+typedef enum CvLeeParameters\n+{\n+    CV_LEE_INT = 0,\n+    CV_LEE_FLOAT = 1,\n+    CV_LEE_DOUBLE = 2,\n+    CV_LEE_AUTO = -1,\n+    CV_LEE_ERODE = 0,\n+    CV_LEE_ZOOM = 1,\n+    CV_LEE_NON = 2\n+} CvLeeParameters;\n+\n+#define CV_NEXT_VORONOISITE2D( SITE ) ((SITE)->edge[0]->site[((SITE)->edge[0]->site[0] == (SITE))])\n+#define CV_PREV_VORONOISITE2D( SITE ) ((SITE)->edge[1]->site[((SITE)->edge[1]->site[0] == (SITE))])\n+#define CV_FIRST_VORONOIEDGE2D( SITE ) ((SITE)->edge[0])\n+#define CV_LAST_VORONOIEDGE2D( SITE ) ((SITE)->edge[1])\n+#define CV_NEXT_VORONOIEDGE2D( EDGE, SITE ) ((EDGE)->next[(EDGE)->site[0] != (SITE)])\n+#define CV_PREV_VORONOIEDGE2D( EDGE, SITE ) ((EDGE)->next[2 + ((EDGE)->site[0] != (SITE))])\n+#define CV_VORONOIEDGE2D_BEGINNODE( EDGE, SITE ) ((EDGE)->node[((EDGE)->site[0] != (SITE))])\n+#define CV_VORONOIEDGE2D_ENDNODE( EDGE, SITE ) ((EDGE)->node[((EDGE)->site[0] == (SITE))])\n+#define CV_TWIN_VORONOISITE2D( SITE, EDGE ) ( (EDGE)->site[((EDGE)->site[0] == (SITE))])\n+\n+#define CV_VORONOISITE2D_FIELDS()    \\\n+    struct CvVoronoiNode2D *node[2]; \\\n+    struct CvVoronoiEdge2D *edge[2];\n+\n+typedef struct CvVoronoiSite2D\n+{\n+    CV_VORONOISITE2D_FIELDS()\n+    struct CvVoronoiSite2D *next[2];\n+} CvVoronoiSite2D;\n+\n+#define CV_VORONOIEDGE2D_FIELDS()    \\\n+    struct CvVoronoiNode2D *node[2]; \\\n+    struct CvVoronoiSite2D *site[2]; \\\n+    struct CvVoronoiEdge2D *next[4];\n+\n+typedef struct CvVoronoiEdge2D\n+{\n+    CV_VORONOIEDGE2D_FIELDS()\n+} CvVoronoiEdge2D;\n+\n+#define CV_VORONOINODE2D_FIELDS()       \\\n+    CV_SET_ELEM_FIELDS(CvVoronoiNode2D) \\\n+    CvPoint2D32f pt;                    \\\n+    float radius;\n+\n+typedef struct CvVoronoiNode2D\n+{\n+    CV_VORONOINODE2D_FIELDS()\n+} CvVoronoiNode2D;\n+\n+#define CV_VORONOIDIAGRAM2D_FIELDS() \\\n+    CV_GRAPH_FIELDS()                \\\n+    CvSet *sites;\n+\n+typedef struct CvVoronoiDiagram2D\n+{\n+    CV_VORONOIDIAGRAM2D_FIELDS()\n+} CvVoronoiDiagram2D;\n+\n+/* Computes Voronoi Diagram for given polygons with holes */\n+CVAPI(int)  cvVoronoiDiagramFromContour(CvSeq* ContourSeq,\n+                                           CvVoronoiDiagram2D** VoronoiDiagram,\n+                                           CvMemStorage* VoronoiStorage,\n+                                           CvLeeParameters contour_type CV_DEFAULT(CV_LEE_INT),\n+                                           int contour_orientation CV_DEFAULT(-1),\n+                                           int attempt_number CV_DEFAULT(10));\n+\n+/* Computes Voronoi Diagram for domains in given image */\n+CVAPI(int)  cvVoronoiDiagramFromImage(IplImage* pImage,\n+                                         CvSeq** ContourSeq,\n+                                         CvVoronoiDiagram2D** VoronoiDiagram,\n+                                         CvMemStorage* VoronoiStorage,\n+                                         CvLeeParameters regularization_method CV_DEFAULT(CV_LEE_NON),\n+                                         float approx_precision CV_DEFAULT(CV_LEE_AUTO));\n+\n+/* Deallocates the storage */\n+CVAPI(void) cvReleaseVoronoiStorage(CvVoronoiDiagram2D* VoronoiDiagram,\n+                                          CvMemStorage** pVoronoiStorage);\n+\n+/*********************** Linear-Contour Model ****************************/\n+\n+struct CvLCMEdge;\n+struct CvLCMNode;\n+\n+typedef struct CvLCMEdge\n+{\n+    CV_GRAPH_EDGE_FIELDS()\n+    CvSeq* chain;\n+    float width;\n+    int index1;\n+    int index2;\n+} CvLCMEdge;\n+\n+typedef struct CvLCMNode\n+{\n+    CV_GRAPH_VERTEX_FIELDS()\n+    CvContour* contour;\n+} CvLCMNode;\n+\n+\n+/* Computes hybrid model from Voronoi Diagram */\n+CVAPI(CvGraph*) cvLinearContorModelFromVoronoiDiagram(CvVoronoiDiagram2D* VoronoiDiagram,\n+                                                         float maxWidth);\n+\n+/* Releases hybrid model storage */\n+CVAPI(int) cvReleaseLinearContorModelStorage(CvGraph** Graph);\n+\n+\n+/* two stereo-related functions */\n+\n+CVAPI(void) cvInitPerspectiveTransform( CvSize size, const CvPoint2D32f vertex[4], double matrix[3][3],\n+                                              CvArr* rectMap );\n+\n+/*CVAPI(void) cvInitStereoRectification( CvStereoCamera* params,\n+                                             CvArr* rectMap1, CvArr* rectMap2,\n+                                             int do_undistortion );*/\n+\n+/*************************** View Morphing Functions ************************/\n+\n+typedef struct CvMatrix3\n+{\n+    float m[3][3];\n+} CvMatrix3;\n+\n+/* The order of the function corresponds to the order they should appear in\n+   the view morphing pipeline */\n+\n+/* Finds ending points of scanlines on left and right images of stereo-pair */\n+CVAPI(void)  cvMakeScanlines( const CvMatrix3* matrix, CvSize  img_size,\n+                              int*  scanlines1, int*  scanlines2,\n+                              int*  lengths1, int*  lengths2,\n+                              int*  line_count );\n+\n+/* Grab pixel values from scanlines and stores them sequentially\n+   (some sort of perspective image transform) */\n+CVAPI(void)  cvPreWarpImage( int       line_count,\n+                             IplImage* img,\n+                             uchar*    dst,\n+                             int*      dst_nums,\n+                             int*      scanlines);\n+\n+/* Approximate each grabbed scanline by a sequence of runs\n+   (lossy run-length compression) */\n+CVAPI(void)  cvFindRuns( int    line_count,\n+                         uchar* prewarp1,\n+                         uchar* prewarp2,\n+                         int*   line_lengths1,\n+                         int*   line_lengths2,\n+                         int*   runs1,\n+                         int*   runs2,\n+                         int*   num_runs1,\n+                         int*   num_runs2);\n+\n+/* Compares two sets of compressed scanlines */\n+CVAPI(void)  cvDynamicCorrespondMulti( int  line_count,\n+                                       int* first,\n+                                       int* first_runs,\n+                                       int* second,\n+                                       int* second_runs,\n+                                       int* first_corr,\n+                                       int* second_corr);\n+\n+/* Finds scanline ending coordinates for some intermediate \"virtual\" camera position */\n+CVAPI(void)  cvMakeAlphaScanlines( int*  scanlines1,\n+                                   int*  scanlines2,\n+                                   int*  scanlinesA,\n+                                   int*  lengths,\n+                                   int   line_count,\n+                                   float alpha);\n+\n+/* Blends data of the left and right image scanlines to get\n+   pixel values of \"virtual\" image scanlines */\n+CVAPI(void)  cvMorphEpilinesMulti( int    line_count,\n+                                   uchar* first_pix,\n+                                   int*   first_num,\n+                                   uchar* second_pix,\n+                                   int*   second_num,\n+                                   uchar* dst_pix,\n+                                   int*   dst_num,\n+                                   float  alpha,\n+                                   int*   first,\n+                                   int*   first_runs,\n+                                   int*   second,\n+                                   int*   second_runs,\n+                                   int*   first_corr,\n+                                   int*   second_corr);\n+\n+/* Does reverse warping of the morphing result to make\n+   it fill the destination image rectangle */\n+CVAPI(void)  cvPostWarpImage( int       line_count,\n+                              uchar*    src,\n+                              int*      src_nums,\n+                              IplImage* img,\n+                              int*      scanlines);\n+\n+/* Deletes Moire (missed pixels that appear due to discretization) */\n+CVAPI(void)  cvDeleteMoire( IplImage*  img );\n+\n+\n+typedef struct CvConDensation\n+{\n+    int MP;\n+    int DP;\n+    float* DynamMatr;       /* Matrix of the linear Dynamics system  */\n+    float* State;           /* Vector of State                       */\n+    int SamplesNum;         /* Number of the Samples                 */\n+    float** flSamples;      /* arr of the Sample Vectors             */\n+    float** flNewSamples;   /* temporary array of the Sample Vectors */\n+    float* flConfidence;    /* Confidence for each Sample            */\n+    float* flCumulative;    /* Cumulative confidence                 */\n+    float* Temp;            /* Temporary vector                      */\n+    float* RandomSample;    /* RandomVector to update sample set     */\n+    struct CvRandState* RandS; /* Array of structures to generate random vectors */\n+} CvConDensation;\n+\n+/* Creates ConDensation filter state */\n+CVAPI(CvConDensation*)  cvCreateConDensation( int dynam_params,\n+                                             int measure_params,\n+                                             int sample_count );\n+\n+/* Releases ConDensation filter state */\n+CVAPI(void)  cvReleaseConDensation( CvConDensation** condens );\n+\n+/* Updates ConDensation filter by time (predict future state of the system) */\n+CVAPI(void)  cvConDensUpdateByTime( CvConDensation* condens);\n+\n+/* Initializes ConDensation filter samples  */\n+CVAPI(void)  cvConDensInitSampleSet( CvConDensation* condens, CvMat* lower_bound, CvMat* upper_bound );\n+\n+CV_INLINE int iplWidth( const IplImage* img )\n+{\n+    return !img ? 0 : !img->roi ? img->width : img->roi->width;\n+}\n+\n+CV_INLINE int iplHeight( const IplImage* img )\n+{\n+    return !img ? 0 : !img->roi ? img->height : img->roi->height;\n+}\n+\n+#ifdef __cplusplus\n+}\n+#endif\n+\n+#ifdef __cplusplus\n+\n+/****************************************************************************************\\\n+*                                   Calibration engine                                   *\n+\\****************************************************************************************/\n+\n+typedef enum CvCalibEtalonType\n+{\n+    CV_CALIB_ETALON_USER = -1,\n+    CV_CALIB_ETALON_CHESSBOARD = 0,\n+    CV_CALIB_ETALON_CHECKERBOARD = CV_CALIB_ETALON_CHESSBOARD\n+}\n+CvCalibEtalonType;\n+\n+class CV_EXPORTS CvCalibFilter\n+{\n+public:\n+    /* Constructor & destructor */\n+    CvCalibFilter();\n+    virtual ~CvCalibFilter();\n+\n+    /* Sets etalon type - one for all cameras.\n+       etalonParams is used in case of pre-defined etalons (such as chessboard).\n+       Number of elements in etalonParams is determined by etalonType.\n+       E.g., if etalon type is CV_ETALON_TYPE_CHESSBOARD then:\n+         etalonParams[0] is number of squares per one side of etalon\n+         etalonParams[1] is number of squares per another side of etalon\n+         etalonParams[2] is linear size of squares in the board in arbitrary units.\n+       pointCount & points are used in case of\n+       CV_CALIB_ETALON_USER (user-defined) etalon. */\n+    virtual bool\n+        SetEtalon( CvCalibEtalonType etalonType, double* etalonParams,\n+                   int pointCount = 0, CvPoint2D32f* points = 0 );\n+\n+    /* Retrieves etalon parameters/or and points */\n+    virtual CvCalibEtalonType\n+        GetEtalon( int* paramCount = 0, const double** etalonParams = 0,\n+                   int* pointCount = 0, const CvPoint2D32f** etalonPoints = 0 ) const;\n+\n+    /* Sets number of cameras calibrated simultaneously. It is equal to 1 initially */\n+    virtual void SetCameraCount( int cameraCount );\n+\n+    /* Retrieves number of cameras */\n+    int GetCameraCount() const { return cameraCount; }\n+\n+    /* Starts cameras calibration */\n+    virtual bool SetFrames( int totalFrames );\n+\n+    /* Stops cameras calibration */\n+    virtual void Stop( bool calibrate = false );\n+\n+    /* Retrieves number of cameras */\n+    bool IsCalibrated() const { return isCalibrated; }\n+\n+    /* Feeds another serie of snapshots (one per each camera) to filter.\n+       Etalon points on these images are found automatically.\n+       If the function can't locate points, it returns false */\n+    virtual bool FindEtalon( IplImage** imgs );\n+\n+    /* The same but takes matrices */\n+    virtual bool FindEtalon( CvMat** imgs );\n+\n+    /* Lower-level function for feeding filter with already found etalon points.\n+       Array of point arrays for each camera is passed. */\n+    virtual bool Push( const CvPoint2D32f** points = 0 );\n+\n+    /* Returns total number of accepted frames and, optionally,\n+       total number of frames to collect */\n+    virtual int GetFrameCount( int* framesTotal = 0 ) const;\n+\n+    /* Retrieves camera parameters for specified camera.\n+       If camera is not calibrated the function returns 0 */\n+    virtual const CvCamera* GetCameraParams( int idx = 0 ) const;\n+\n+    virtual const CvStereoCamera* GetStereoParams() const;\n+\n+    /* Sets camera parameters for all cameras */\n+    virtual bool SetCameraParams( CvCamera* params );\n+\n+    /* Saves all camera parameters to file */\n+    virtual bool SaveCameraParams( const char* filename );\n+\n+    /* Loads all camera parameters from file */\n+    virtual bool LoadCameraParams( const char* filename );\n+\n+    /* Undistorts images using camera parameters. Some of src pointers can be NULL. */\n+    virtual bool Undistort( IplImage** src, IplImage** dst );\n+\n+    /* Undistorts images using camera parameters. Some of src pointers can be NULL. */\n+    virtual bool Undistort( CvMat** src, CvMat** dst );\n+\n+    /* Returns array of etalon points detected/partally detected\n+       on the latest frame for idx-th camera */\n+    virtual bool GetLatestPoints( int idx, CvPoint2D32f** pts,\n+                                                  int* count, bool* found );\n+\n+    /* Draw the latest detected/partially detected etalon */\n+    virtual void DrawPoints( IplImage** dst );\n+\n+    /* Draw the latest detected/partially detected etalon */\n+    virtual void DrawPoints( CvMat** dst );\n+\n+    virtual bool Rectify( IplImage** srcarr, IplImage** dstarr );\n+    virtual bool Rectify( CvMat** srcarr, CvMat** dstarr );\n+\n+protected:\n+\n+    enum { MAX_CAMERAS = 3 };\n+\n+    /* etalon data */\n+    CvCalibEtalonType  etalonType;\n+    int     etalonParamCount;\n+    double* etalonParams;\n+    int     etalonPointCount;\n+    CvPoint2D32f* etalonPoints;\n+    CvSize  imgSize;\n+    CvMat*  grayImg;\n+    CvMat*  tempImg;\n+    CvMemStorage* storage;\n+\n+    /* camera data */\n+    int     cameraCount;\n+    CvCamera cameraParams[MAX_CAMERAS];\n+    CvStereoCamera stereo;\n+    CvPoint2D32f* points[MAX_CAMERAS];\n+    CvMat*  undistMap[MAX_CAMERAS][2];\n+    CvMat*  undistImg;\n+    int     latestCounts[MAX_CAMERAS];\n+    CvPoint2D32f* latestPoints[MAX_CAMERAS];\n+    CvMat*  rectMap[MAX_CAMERAS][2];\n+\n+    /* Added by Valery */\n+    //CvStereoCamera stereoParams;\n+\n+    int     maxPoints;\n+    int     framesTotal;\n+    int     framesAccepted;\n+    bool    isCalibrated;\n+};\n+\n+#include <iosfwd>\n+#include <limits>\n+\n+class CV_EXPORTS CvImage\n+{\n+public:\n+    CvImage() : image(0), refcount(0) {}\n+    CvImage( CvSize _size, int _depth, int _channels )\n+    {\n+        image = cvCreateImage( _size, _depth, _channels );\n+        refcount = image ? new int(1) : 0;\n+    }\n+\n+    CvImage( IplImage* img ) : image(img)\n+    {\n+        refcount = image ? new int(1) : 0;\n+    }\n+\n+    CvImage( const CvImage& img ) : image(img.image), refcount(img.refcount)\n+    {\n+        if( refcount ) ++(*refcount);\n+    }\n+\n+    CvImage( const char* filename, const char* imgname=0, int color=-1 ) : image(0), refcount(0)\n+    { load( filename, imgname, color ); }\n+\n+    CvImage( CvFileStorage* fs, const char* mapname, const char* imgname ) : image(0), refcount(0)\n+    { read( fs, mapname, imgname ); }\n+\n+    CvImage( CvFileStorage* fs, const char* seqname, int idx ) : image(0), refcount(0)\n+    { read( fs, seqname, idx ); }\n+\n+    ~CvImage()\n+    {\n+        if( refcount && !(--*refcount) )\n+        {\n+            cvReleaseImage( &image );\n+            delete refcount;\n+        }\n+    }\n+\n+    CvImage clone() { return CvImage(image ? cvCloneImage(image) : 0); }\n+\n+    void create( CvSize _size, int _depth, int _channels )\n+    {\n+        if( !image || !refcount ||\n+           image->width != _size.width || image->height != _size.height ||\n+           image->depth != _depth || image->nChannels != _channels )\n+            attach( cvCreateImage( _size, _depth, _channels ));\n+    }\n+\n+    void release() { detach(); }\n+    void clear() { detach(); }\n+\n+    void attach( IplImage* img, bool use_refcount=true )\n+    {\n+        if( refcount && --*refcount == 0 )\n+        {\n+            cvReleaseImage( &image );\n+            delete refcount;\n+        }\n+        image = img;\n+        refcount = use_refcount && image ? new int(1) : 0;\n+    }\n+\n+    void detach()\n+    {\n+        if( refcount && --*refcount == 0 )\n+        {\n+            cvReleaseImage( &image );\n+            delete refcount;\n+        }\n+        image = 0;\n+        refcount = 0;\n+    }\n+\n+    bool load( const char* filename, const char* imgname=0, int color=-1 );\n+    bool read( CvFileStorage* fs, const char* mapname, const char* imgname );\n+    bool read( CvFileStorage* fs, const char* seqname, int idx );\n+    void save( const char* filename, const char* imgname, const int* params=0 );\n+    void write( CvFileStorage* fs, const char* imgname );\n+\n+    void show( const char* window_name );\n+    bool is_valid() { return image != 0; }\n+\n+    int width() const { return image ? image->width : 0; }\n+    int height() const { return image ? image->height : 0; }\n+\n+    CvSize size() const { return image ? cvSize(image->width, image->height) : cvSize(0,0); }\n+\n+    CvSize roi_size() const\n+    {\n+        return !image ? cvSize(0,0) :\n+        !image->roi ? cvSize(image->width,image->height) :\n+        cvSize(image->roi->width, image->roi->height);\n+    }\n+\n+    CvRect roi() const\n+    {\n+        return !image ? cvRect(0,0,0,0) :\n+        !image->roi ? cvRect(0,0,image->width,image->height) :\n+        cvRect(image->roi->xOffset,image->roi->yOffset,\n+               image->roi->width,image->roi->height);\n+    }\n+\n+    int coi() const { return !image || !image->roi ? 0 : image->roi->coi; }\n+\n+    void set_roi(CvRect _roi) { cvSetImageROI(image,_roi); }\n+    void reset_roi() { cvResetImageROI(image); }\n+    void set_coi(int _coi) { cvSetImageCOI(image,_coi); }\n+    int depth() const { return image ? image->depth : 0; }\n+    int channels() const { return image ? image->nChannels : 0; }\n+    int pix_size() const { return image ? ((image->depth & 255)>>3)*image->nChannels : 0; }\n+\n+    uchar* data() { return image ? (uchar*)image->imageData : 0; }\n+    const uchar* data() const { return image ? (const uchar*)image->imageData : 0; }\n+    int step() const { return image ? image->widthStep : 0; }\n+    int origin() const { return image ? image->origin : 0; }\n+\n+    uchar* roi_row(int y)\n+    {\n+        assert(0<=y);\n+        assert(!image ?\n+               1 : image->roi ?\n+               y<image->roi->height : y<image->height);\n+\n+        return !image ? 0 :\n+        !image->roi ?\n+        (uchar*)(image->imageData + y*image->widthStep) :\n+        (uchar*)(image->imageData + (y+image->roi->yOffset)*image->widthStep +\n+                 image->roi->xOffset*((image->depth & 255)>>3)*image->nChannels);\n+    }\n+\n+    const uchar* roi_row(int y) const\n+    {\n+        assert(0<=y);\n+        assert(!image ?\n+               1 : image->roi ?\n+               y<image->roi->height : y<image->height);\n+\n+        return !image ? 0 :\n+        !image->roi ?\n+        (const uchar*)(image->imageData + y*image->widthStep) :\n+        (const uchar*)(image->imageData + (y+image->roi->yOffset)*image->widthStep +\n+                       image->roi->xOffset*((image->depth & 255)>>3)*image->nChannels);\n+    }\n+\n+    operator const IplImage* () const { return image; }\n+    operator IplImage* () { return image; }\n+\n+    CvImage& operator = (const CvImage& img)\n+    {\n+        if( img.refcount )\n+            ++*img.refcount;\n+        if( refcount && !(--*refcount) )\n+            cvReleaseImage( &image );\n+        image=img.image;\n+        refcount=img.refcount;\n+        return *this;\n+    }\n+\n+protected:\n+    IplImage* image;\n+    int* refcount;\n+};\n+\n+\n+class CV_EXPORTS CvMatrix\n+{\n+public:\n+    CvMatrix() : matrix(0) {}\n+    CvMatrix( int _rows, int _cols, int _type )\n+    { matrix = cvCreateMat( _rows, _cols, _type ); }\n+\n+    CvMatrix( int _rows, int _cols, int _type, CvMat* hdr,\n+             void* _data=0, int _step=CV_AUTOSTEP )\n+    { matrix = cvInitMatHeader( hdr, _rows, _cols, _type, _data, _step ); }\n+\n+    CvMatrix( int rows, int cols, int type, CvMemStorage* storage, bool alloc_data=true );\n+\n+    CvMatrix( int _rows, int _cols, int _type, void* _data, int _step=CV_AUTOSTEP )\n+    { matrix = cvCreateMatHeader( _rows, _cols, _type );\n+        cvSetData( matrix, _data, _step ); }\n+\n+    CvMatrix( CvMat* m )\n+    { matrix = m; }\n+\n+    CvMatrix( const CvMatrix& m )\n+    {\n+        matrix = m.matrix;\n+        addref();\n+    }\n+\n+    CvMatrix( const char* filename, const char* matname=0, int color=-1 ) : matrix(0)\n+    {  load( filename, matname, color ); }\n+\n+    CvMatrix( CvFileStorage* fs, const char* mapname, const char* matname ) : matrix(0)\n+    {  read( fs, mapname, matname ); }\n+\n+    CvMatrix( CvFileStorage* fs, const char* seqname, int idx ) : matrix(0)\n+    {  read( fs, seqname, idx ); }\n+\n+    ~CvMatrix()\n+    {\n+        release();\n+    }\n+\n+    CvMatrix clone() { return CvMatrix(matrix ? cvCloneMat(matrix) : 0); }\n+\n+    void set( CvMat* m, bool add_ref )\n+    {\n+        release();\n+        matrix = m;\n+        if( add_ref )\n+            addref();\n+    }\n+\n+    void create( int _rows, int _cols, int _type )\n+    {\n+        if( !matrix || !matrix->refcount ||\n+           matrix->rows != _rows || matrix->cols != _cols ||\n+           CV_MAT_TYPE(matrix->type) != _type )\n+            set( cvCreateMat( _rows, _cols, _type ), false );\n+    }\n+\n+    void addref() const\n+    {\n+        if( matrix )\n+        {\n+            if( matrix->hdr_refcount )\n+                ++matrix->hdr_refcount;\n+            else if( matrix->refcount )\n+                ++*matrix->refcount;\n+        }\n+    }\n+\n+    void release()\n+    {\n+        if( matrix )\n+        {\n+            if( matrix->hdr_refcount )\n+            {\n+                if( --matrix->hdr_refcount == 0 )\n+                    cvReleaseMat( &matrix );\n+            }\n+            else if( matrix->refcount )\n+            {\n+                if( --*matrix->refcount == 0 )\n+                    cvFree( &matrix->refcount );\n+            }\n+            matrix = 0;\n+        }\n+    }\n+\n+    void clear()\n+    {\n+        release();\n+    }\n+\n+    bool load( const char* filename, const char* matname=0, int color=-1 );\n+    bool read( CvFileStorage* fs, const char* mapname, const char* matname );\n+    bool read( CvFileStorage* fs, const char* seqname, int idx );\n+    void save( const char* filename, const char* matname, const int* params=0 );\n+    void write( CvFileStorage* fs, const ","path":"app/src/main/jni/include/opencv2/legacy/legacy.hpp","position":null,"original_position":3316,"commit_id":"a84873748fc465b1b97f12137781f7188fab5428","original_commit_id":"a84873748fc465b1b97f12137781f7188fab5428","user":{"login":"codacy-bot","id":19940114,"avatar_url":"https://avatars1.githubusercontent.com/u/19940114?v=4","gravatar_id":"","url":"https://api.github.com/users/codacy-bot","html_url":"https://github.com/codacy-bot","followers_url":"https://api.github.com/users/codacy-bot/followers","following_url":"https://api.github.com/users/codacy-bot/following{/other_user}","gists_url":"https://api.github.com/users/codacy-bot/gists{/gist_id}","starred_url":"https://api.github.com/users/codacy-bot/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/codacy-bot/subscriptions","organizations_url":"https://api.github.com/users/codacy-bot/orgs","repos_url":"https://api.github.com/users/codacy-bot/repos","events_url":"https://api.github.com/users/codacy-bot/events{/privacy}","received_events_url":"https://api.github.com/users/codacy-bot/received_events","type":"User","site_admin":false},"body":"![Codacy](https://app.codacy.com/assets/images/favicon.png) Issue found: [struct member 'CvFGDStatModel::Ftd' is never used.](https://app.codacy.com/app/harshithdwivedi/phimpme-android/pullRequest?prid=1494592)","created_at":"2018-04-01T16:13:10Z","updated_at":"2018-04-01T16:13:11Z","html_url":"https://github.com/fossasia/phimpme-android/pull/1980#discussion_r178462489","pull_request_url":"https://api.github.com/repos/fossasia/phimpme-android/pulls/1980","author_association":"NONE","_links":{"self":{"href":"https://api.github.com/repos/fossasia/phimpme-android/pulls/comments/178462489"},"html":{"href":"https://github.com/fossasia/phimpme-android/pull/1980#discussion_r178462489"},"pull_request":{"href":"https://api.github.com/repos/fossasia/phimpme-android/pulls/1980"}}},"pull_request":{"url":"https://api.github.com/repos/fossasia/phimpme-android/pulls/1980","id":178735824,"html_url":"https://github.com/fossasia/phimpme-android/pull/1980","diff_url":"https://github.com/fossasia/phimpme-android/pull/1980.diff","patch_url":"https://github.com/fossasia/phimpme-android/pull/1980.patch","issue_url":"https://api.github.com/repos/fossasia/phimpme-android/issues/1980","number":1980,"state":"open","locked":false,"title":"Added Bone Filter","user":{"login":"yashLadha","id":18033231,"avatar_url":"https://avatars3.githubusercontent.com/u/18033231?v=4","gravatar_id":"","url":"https://api.github.com/users/yashLadha","html_url":"https://github.com/yashLadha","followers_url":"https://api.github.com/users/yashLadha/followers","following_url":"https://api.github.com/users/yashLadha/following{/other_user}","gists_url":"https://api.github.com/users/yashLadha/gists{/gist_id}","starred_url":"https://api.github.com/users/yashLadha/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/yashLadha/subscriptions","organizations_url":"https://api.github.com/users/yashLadha/orgs","repos_url":"https://api.github.com/users/yashLadha/repos","events_url":"https://api.github.com/users/yashLadha/events{/privacy}","received_events_url":"https://api.github.com/users/yashLadha/received_events","type":"User","site_admin":false},"body":"Fixes : #1979 \r\n\r\nScreenshots of the change: \r\n\r\nBefore:\r\n\r\n![screenshot2](https://user-images.githubusercontent.com/18033231/38175119-3258b960-35f5-11e8-88b6-4dcd47d2c065.png)\r\n\r\nAfter:\r\n\r\n![screenshot1511](https://user-images.githubusercontent.com/18033231/38175120-379c7a92-35f5-11e8-8b5d-0a187d5ef511.png)\r\n\r\n","created_at":"2018-04-01T16:09:59Z","updated_at":"2018-04-01T16:13:11Z","closed_at":null,"merged_at":null,"merge_commit_sha":"ac878d74c8cab9a62af44cdeaed1ea2732fd187f","assignee":null,"assignees":[],"requested_reviewers":[],"requested_teams":[],"labels":[],"milestone":null,"commits_url":"https://api.github.com/repos/fossasia/phimpme-android/pulls/1980/commits","review_comments_url":"https://api.github.com/repos/fossasia/phimpme-android/pulls/1980/comments","review_comment_url":"https://api.github.com/repos/fossasia/phimpme-android/pulls/comments{/number}","comments_url":"https://api.github.com/repos/fossasia/phimpme-android/issues/1980/comments","statuses_url":"https://api.github.com/repos/fossasia/phimpme-android/statuses/a84873748fc465b1b97f12137781f7188fab5428","head":{"label":"yashLadha:bone-effect","ref":"bone-effect","sha":"a84873748fc465b1b97f12137781f7188fab5428","user":{"login":"yashLadha","id":18033231,"avatar_url":"https://avatars3.githubusercontent.com/u/18033231?v=4","gravatar_id":"","url":"https://api.github.com/users/yashLadha","html_url":"https://github.com/yashLadha","followers_url":"https://api.github.com/users/yashLadha/followers","following_url":"https://api.github.com/users/yashLadha/following{/other_user}","gists_url":"https://api.github.com/users/yashLadha/gists{/gist_id}","starred_url":"https://api.github.com/users/yashLadha/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/yashLadha/subscriptions","organizations_url":"https://api.github.com/users/yashLadha/orgs","repos_url":"https://api.github.com/users/yashLadha/repos","events_url":"https://api.github.com/users/yashLadha/events{/privacy}","received_events_url":"https://api.github.com/users/yashLadha/received_events","type":"User","site_admin":false},"repo":{"id":123433574,"name":"phimpme-android","full_name":"yashLadha/phimpme-android","owner":{"login":"yashLadha","id":18033231,"avatar_url":"https://avatars3.githubusercontent.com/u/18033231?v=4","gravatar_id":"","url":"https://api.github.com/users/yashLadha","html_url":"https://github.com/yashLadha","followers_url":"https://api.github.com/users/yashLadha/followers","following_url":"https://api.github.com/users/yashLadha/following{/other_user}","gists_url":"https://api.github.com/users/yashLadha/gists{/gist_id}","starred_url":"https://api.github.com/users/yashLadha/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/yashLadha/subscriptions","organizations_url":"https://api.github.com/users/yashLadha/orgs","repos_url":"https://api.github.com/users/yashLadha/repos","events_url":"https://api.github.com/users/yashLadha/events{/privacy}","received_events_url":"https://api.github.com/users/yashLadha/received_events","type":"User","site_admin":false},"private":false,"html_url":"https://github.com/yashLadha/phimpme-android","description":"Phimp.me - Photo Image Editor App https://phimp.me","fork":true,"url":"https://api.github.com/repos/yashLadha/phimpme-android","forks_url":"https://api.github.com/repos/yashLadha/phimpme-android/forks","keys_url":"https://api.github.com/repos/yashLadha/phimpme-android/keys{/key_id}","collaborators_url":"https://api.github.com/repos/yashLadha/phimpme-android/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/yashLadha/phimpme-android/teams","hooks_url":"https://api.github.com/repos/yashLadha/phimpme-android/hooks","issue_events_url":"https://api.github.com/repos/yashLadha/phimpme-android/issues/events{/number}","events_url":"https://api.github.com/repos/yashLadha/phimpme-android/events","assignees_url":"https://api.github.com/repos/yashLadha/phimpme-android/assignees{/user}","branches_url":"https://api.github.com/repos/yashLadha/phimpme-android/branches{/branch}","tags_url":"https://api.github.com/repos/yashLadha/phimpme-android/tags","blobs_url":"https://api.github.com/repos/yashLadha/phimpme-android/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/yashLadha/phimpme-android/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/yashLadha/phimpme-android/git/refs{/sha}","trees_url":"https://api.github.com/repos/yashLadha/phimpme-android/git/trees{/sha}","statuses_url":"https://api.github.com/repos/yashLadha/phimpme-android/statuses/{sha}","languages_url":"https://api.github.com/repos/yashLadha/phimpme-android/languages","stargazers_url":"https://api.github.com/repos/yashLadha/phimpme-android/stargazers","contributors_url":"https://api.github.com/repos/yashLadha/phimpme-android/contributors","subscribers_url":"https://api.github.com/repos/yashLadha/phimpme-android/subscribers","subscription_url":"https://api.github.com/repos/yashLadha/phimpme-android/subscription","commits_url":"https://api.github.com/repos/yashLadha/phimpme-android/commits{/sha}","git_commits_url":"https://api.github.com/repos/yashLadha/phimpme-android/git/commits{/sha}","comments_url":"https://api.github.com/repos/yashLadha/phimpme-android/comments{/number}","issue_comment_url":"https://api.github.com/repos/yashLadha/phimpme-android/issues/comments{/number}","contents_url":"https://api.github.com/repos/yashLadha/phimpme-android/contents/{+path}","compare_url":"https://api.github.com/repos/yashLadha/phimpme-android/compare/{base}...{head}","merges_url":"https://api.github.com/repos/yashLadha/phimpme-android/merges","archive_url":"https://api.github.com/repos/yashLadha/phimpme-android/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/yashLadha/phimpme-android/downloads","issues_url":"https://api.github.com/repos/yashLadha/phimpme-android/issues{/number}","pulls_url":"https://api.github.com/repos/yashLadha/phimpme-android/pulls{/number}","milestones_url":"https://api.github.com/repos/yashLadha/phimpme-android/milestones{/number}","notifications_url":"https://api.github.com/repos/yashLadha/phimpme-android/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/yashLadha/phimpme-android/labels{/name}","releases_url":"https://api.github.com/repos/yashLadha/phimpme-android/releases{/id}","deployments_url":"https://api.github.com/repos/yashLadha/phimpme-android/deployments","created_at":"2018-03-01T12:43:29Z","updated_at":"2018-03-14T13:46:04Z","pushed_at":"2018-04-01T16:07:50Z","git_url":"git://github.com/yashLadha/phimpme-android.git","ssh_url":"git@github.com:yashLadha/phimpme-android.git","clone_url":"https://github.com/yashLadha/phimpme-android.git","svn_url":"https://github.com/yashLadha/phimpme-android","homepage":"","size":192277,"stargazers_count":0,"watchers_count":0,"language":"Java","has_issues":false,"has_projects":true,"has_downloads":true,"has_wiki":false,"has_pages":false,"forks_count":0,"mirror_url":null,"archived":false,"open_issues_count":0,"license":{"key":"other","name":"Other","spdx_id":null,"url":null},"forks":0,"open_issues":0,"watchers":0,"default_branch":"development"}},"base":{"label":"fossasia:development","ref":"development","sha":"5d967ccb4daff21fec1afd3e6441552977189617","user":{"login":"fossasia","id":6295529,"avatar_url":"https://avatars3.githubusercontent.com/u/6295529?v=4","gravatar_id":"","url":"https://api.github.com/users/fossasia","html_url":"https://github.com/fossasia","followers_url":"https://api.github.com/users/fossasia/followers","following_url":"https://api.github.com/users/fossasia/following{/other_user}","gists_url":"https://api.github.com/users/fossasia/gists{/gist_id}","starred_url":"https://api.github.com/users/fossasia/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/fossasia/subscriptions","organizations_url":"https://api.github.com/users/fossasia/orgs","repos_url":"https://api.github.com/users/fossasia/repos","events_url":"https://api.github.com/users/fossasia/events{/privacy}","received_events_url":"https://api.github.com/users/fossasia/received_events","type":"Organization","site_admin":false},"repo":{"id":5713702,"name":"phimpme-android","full_name":"fossasia/phimpme-android","owner":{"login":"fossasia","id":6295529,"avatar_url":"https://avatars3.githubusercontent.com/u/6295529?v=4","gravatar_id":"","url":"https://api.github.com/users/fossasia","html_url":"https://github.com/fossasia","followers_url":"https://api.github.com/users/fossasia/followers","following_url":"https://api.github.com/users/fossasia/following{/other_user}","gists_url":"https://api.github.com/users/fossasia/gists{/gist_id}","starred_url":"https://api.github.com/users/fossasia/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/fossasia/subscriptions","organizations_url":"https://api.github.com/users/fossasia/orgs","repos_url":"https://api.github.com/users/fossasia/repos","events_url":"https://api.github.com/users/fossasia/events{/privacy}","received_events_url":"https://api.github.com/users/fossasia/received_events","type":"Organization","site_admin":false},"private":false,"html_url":"https://github.com/fossasia/phimpme-android","description":"Phimp.me - Photo Image Editor App https://phimp.me","fork":false,"url":"https://api.github.com/repos/fossasia/phimpme-android","forks_url":"https://api.github.com/repos/fossasia/phimpme-android/forks","keys_url":"https://api.github.com/repos/fossasia/phimpme-android/keys{/key_id}","collaborators_url":"https://api.github.com/repos/fossasia/phimpme-android/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/fossasia/phimpme-android/teams","hooks_url":"https://api.github.com/repos/fossasia/phimpme-android/hooks","issue_events_url":"https://api.github.com/repos/fossasia/phimpme-android/issues/events{/number}","events_url":"https://api.github.com/repos/fossasia/phimpme-android/events","assignees_url":"https://api.github.com/repos/fossasia/phimpme-android/assignees{/user}","branches_url":"https://api.github.com/repos/fossasia/phimpme-android/branches{/branch}","tags_url":"https://api.github.com/repos/fossasia/phimpme-android/tags","blobs_url":"https://api.github.com/repos/fossasia/phimpme-android/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/fossasia/phimpme-android/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/fossasia/phimpme-android/git/refs{/sha}","trees_url":"https://api.github.com/repos/fossasia/phimpme-android/git/trees{/sha}","statuses_url":"https://api.github.com/repos/fossasia/phimpme-android/statuses/{sha}","languages_url":"https://api.github.com/repos/fossasia/phimpme-android/languages","stargazers_url":"https://api.github.com/repos/fossasia/phimpme-android/stargazers","contributors_url":"https://api.github.com/repos/fossasia/phimpme-android/contributors","subscribers_url":"https://api.github.com/repos/fossasia/phimpme-android/subscribers","subscription_url":"https://api.github.com/repos/fossasia/phimpme-android/subscription","commits_url":"https://api.github.com/repos/fossasia/phimpme-android/commits{/sha}","git_commits_url":"https://api.github.com/repos/fossasia/phimpme-android/git/commits{/sha}","comments_url":"https://api.github.com/repos/fossasia/phimpme-android/comments{/number}","issue_comment_url":"https://api.github.com/repos/fossasia/phimpme-android/issues/comments{/number}","contents_url":"https://api.github.com/repos/fossasia/phimpme-android/contents/{+path}","compare_url":"https://api.github.com/repos/fossasia/phimpme-android/compare/{base}...{head}","merges_url":"https://api.github.com/repos/fossasia/phimpme-android/merges","archive_url":"https://api.github.com/repos/fossasia/phimpme-android/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/fossasia/phimpme-android/downloads","issues_url":"https://api.github.com/repos/fossasia/phimpme-android/issues{/number}","pulls_url":"https://api.github.com/repos/fossasia/phimpme-android/pulls{/number}","milestones_url":"https://api.github.com/repos/fossasia/phimpme-android/milestones{/number}","notifications_url":"https://api.github.com/repos/fossasia/phimpme-android/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/fossasia/phimpme-android/labels{/name}","releases_url":"https://api.github.com/repos/fossasia/phimpme-android/releases{/id}","deployments_url":"https://api.github.com/repos/fossasia/phimpme-android/deployments","created_at":"2012-09-07T07:14:54Z","updated_at":"2018-03-31T19:16:44Z","pushed_at":"2018-04-01T16:10:00Z","git_url":"git://github.com/fossasia/phimpme-android.git","ssh_url":"git@github.com:fossasia/phimpme-android.git","clone_url":"https://github.com/fossasia/phimpme-android.git","svn_url":"https://github.com/fossasia/phimpme-android","homepage":"","size":192282,"stargazers_count":678,"watchers_count":678,"language":"Java","has_issues":true,"has_projects":false,"has_downloads":true,"has_wiki":false,"has_pages":true,"forks_count":360,"mirror_url":null,"archived":false,"open_issues_count":132,"license":{"key":"other","name":"Other","spdx_id":null,"url":null},"forks":360,"open_issues":132,"watchers":678,"default_branch":"development"}},"_links":{"self":{"href":"https://api.github.com/repos/fossasia/phimpme-android/pulls/1980"},"html":{"href":"https://github.com/fossasia/phimpme-android/pull/1980"},"issue":{"href":"https://api.github.com/repos/fossasia/phimpme-android/issues/1980"},"comments":{"href":"https://api.github.com/repos/fossasia/phimpme-android/issues/1980/comments"},"review_comments":{"href":"https://api.github.com/repos/fossasia/phimpme-android/pulls/1980/comments"},"review_comment":{"href":"https://api.github.com/repos/fossasia/phimpme-android/pulls/comments{/number}"},"commits":{"href":"https://api.github.com/repos/fossasia/phimpme-android/pulls/1980/commits"},"statuses":{"href":"https://api.github.com/repos/fossasia/phimpme-android/statuses/a84873748fc465b1b97f12137781f7188fab5428"}},"author_association":"MEMBER"}}
{"actor":{"display_login":"codacy-bot"}}