private class ConvexityDefect {

		private Point mStart;

		private Point mEnd;

		private Point mDepthPoint;

		private float mDepth;

		public Point getStart(){

			return mStart;

		}

		public Point getEnd(){

			return mEnd;

		}

		public Point getDepthPoint(){

			return mDepthPoint;

		}

		public float getDepth(){

			return mDepth;

		}

		public void setStart(Point start){

			this.mStart = start;

		}

		public void setEnd(Point end){

			this.mEnd = end;

		}

		public void setDepthPoint(Point DepthPoint){

			this.mDepthPoint = DepthPoint;

		}

		public void setDepth(float depth){

			this.mDepth = depth;

		}

	}

	public List<ConvexityDefect> findConvexityDefects(Mat contour, List<Point> hullPts){

		List<Point> contourPts = new ArrayList<Point>();

		List<ConvexityDefect> defects = new ArrayList<ConvexityDefect>();

		Converters.Mat_to_vector_Point(contour, contourPts);

		if(contourPts.size() < 4 || hullPts.size() < 3)

		{

			// Error: Contour size must be >= 4 and convex hull size must be >= 3 

			return null; 

		}

		// Co-Orientation of Contour and it's Hull

		int sign = 0;

		int index1, index2, index3;

		Point pos, hull_cur, contour_cur;

		pos = hullPts.get(0);

		index1 = contourPts.indexOf(pos);

		pos = hullPts.get(1);

		index2 = contourPts.indexOf(pos);

		pos = hullPts.get(2);

		index3 = contourPts.indexOf(pos);

		sign += (index2 > index1) ? 1 : 0;

		sign += (index3 > index2) ? 1 : 0;

		sign += (index1 > index3) ? 1 : 0;

		if(sign == 1) // 0: same orientation 1: reverse orientation

			Collections.reverse(hullPts);

		// Cycle through the contour and hull

		for( int i = 0; i < hullPts.size(); i++ )

		{

			double dx0, dy0;

			double depth = 0, scale;

			boolean is_defect = false;

			Point hull_next;

			ConvexityDefect defect = new ConvexityDefect();

			hull_cur = hullPts.get(i); 

			if(i + 1 == hullPts.size()) // Caculate the defect between the last hull point and the first

				hull_next = hullPts.get(0); // First point of the hull

			else

				hull_next = hullPts.get(i+1);

			dx0 = hull_next.x - hull_cur.x;

			dy0 = hull_next.y - hull_cur.y;

			assert( dx0 != 0 || dy0 != 0 );

			scale = 1/Math.sqrt(dx0*dx0 + dy0*dy0);

			defect.setStart(hull_cur);

			defect.setEnd(hull_next);

			// Cycle through the contour till next hull point

			for( int k = contourPts.indexOf(hullPts.get(i)); k < contourPts.size() ; k++ )

			{

				contour_cur = contourPts.get(k); // Next contour point between the 2 hull points

				if(contour_cur.equals(hull_next)) // If we have reached the second hull point, stop cycling through the contour

					break;

				else

				{	

					if(k + 1 == contourPts.size()) // If the contour reached the end, start from the first point

					{

						k = 0; // Reset the index to the first point of the contour

						contour_cur = contourPts.get(k); // Next contour point between the 2 hull points

						if(contour_cur.equals(hull_next))

							break;

					}

					// Compute distance from current point to the hull edge

					double dx = contour_cur.x - hull_cur.x;

					double dy = contour_cur.y - hull_cur.y;

					// Compute depth

					double dist = Math.abs(-dy0*dx + dx0*dy) * scale;

					if( dist > depth )

					{

						depth = dist;

						defect.setDepthPoint(contour_cur);

						defect.setDepth((float)depth);

						is_defect = true;

					}

				}

			}

			if(is_defect)

			{

				defects.add(defect);

				is_defect = false;

			}

		}

		return defects;

	}