+(UIImage *) androidWatershedTest:(UIImage *)FinalOriginalBmp:(UIImage *)orgoriginalBmp
{
cv::Mat extractedImage;//(orgoriginalBmp.size.width, orgoriginalBmp.size.height, CV_8UC1);
UIImageToMat(orgoriginalBmp, extractedImage);

extractedImage.convertTo(extractedImage, CV_8UC4);

cv::Mat orginal(orgoriginalBmp.size.width, orgoriginalBmp.size.height, CV_8UC1);
extractedImage.copyTo(orginal);

extractedImage.convertTo(extractedImage, CV_8UC1);

cv::threshold(extractedImage, extractedImage, 40, 255, cv::THRESH_OTSU);


cv::Mat distanceTransformMat(FinalOriginalBmp.size.width, FinalOriginalBmp.size.height,CV_8UC1);

cv::distanceTransform(extractedImage, distanceTransformMat, CV_DIST_L2, 3);

cv::normalize(distanceTransformMat, distanceTransformMat, 0.0, 255, cv::NORM_MINMAX);

cv::Mat dilate(orgoriginalBmp.size.height, orgoriginalBmp.size.width, CV_8UC1, cv::Scalar(20));

distanceTransformMat.convertTo(dilate, CV_8UC1);

cv::Mat maximaGatheringMat;

dilate.copyTo(maximaGatheringMat);

std::vector<cv::Point> LocalMaximaPoints;
for (int j = 0; j < maximaGatheringMat.rows; j++) {
    for (int k = 0; k < maximaGatheringMat.cols; k++) {
        cv::Vec3b pixel = maximaGatheringMat.at<cv::Vec3b>(j, k);

        cv::Vec3b uppixel = maximaGatheringMat.at<cv::Vec3b>(j + 1, k);
        cv::Vec3b downpixel = maximaGatheringMat.at<cv::Vec3b>(j - 1, k);
        cv::Vec3b rightpixel = maximaGatheringMat.at<cv::Vec3b>(j, k - 1);
        cv::Vec3b leftpixel = maximaGatheringMat.at<cv::Vec3b>(j, k + 1);
        cv::Vec3b uppixelright = maximaGatheringMat.at<cv::Vec3b>(j + 1, k - 1);
        cv::Vec3b uppixelleft = maximaGatheringMat.at<cv::Vec3b>(j + 1, k + 1);
        cv::Vec3b downpixelright = maximaGatheringMat.at<cv::Vec3b>(j - 1, k - 1);
        cv::Vec3b downpixelleft = maximaGatheringMat.at<cv::Vec3b>(j - 1, k + 1);

        if (pixel[0] > 0) {


            if (uppixel != cv::Vec3b(0,0,0)
                && downpixel != cv::Vec3b(0,0,0)
                && rightpixel != cv::Vec3b(0,0,0)
                && leftpixel != cv::Vec3b(0,0,0)
                && uppixelright != cv::Vec3b(0,0,0)
                && uppixelleft != cv::Vec3b(0,0,0)
                && downpixelright != cv::Vec3b(0,0,0)
                && downpixelleft != cv::Vec3b(0,0,0)) {

                if (pixel[0] >= uppixel[0]
                    && pixel[0] >= downpixel[0]
                    && pixel[0] >= rightpixel[0]
                    && pixel[0] >= leftpixel[0]
                    && pixel[0] >= uppixelright[0]
                    && pixel[0] >= uppixelleft[0]
                    && pixel[0] >= downpixelright[0]
                    && pixel[0] >= downpixelleft[0]) {

                    cv::Point point(k, j);
                    LocalMaximaPoints.push_back(point);

                }

            }
        }
    }
}

cv::Mat drawnMaxMAt (FinalOriginalBmp.size.width, FinalOriginalBmp.size.height, CV_8UC1, CvScalar(255));

for (int pls = 0; pls < LocalMaximaPoints.size(); pls++) {

    cv::circle(drawnMaxMAt, LocalMaximaPoints[pls], 1, cv::Scalar(0, 255, 0), -1, 1, 0);
}

std::vector<std::vector<cv::Point>> PointFilterMatContours;
std::vector<cv::Vec4i> hierarchy1ttt;//may need to change

cv::findContours(drawnMaxMAt, PointFilterMatContours, hierarchy1ttt, cv::RETR_CCOMP, cv::CHAIN_APPROX_SIMPLE);

cv::Mat PointFilterMat (drawnMaxMAt.size(), CV_8UC1, CvScalar(0));

std::vector<cv::Moments> mu(PointFilterMatContours.size());
std::vector<cv::Point> FilteredPoints(PointFilterMatContours.size());

for (int i = 0; i < PointFilterMatContours.size(); i++) {
    mu.push_back(cv::moments(PointFilterMatContours[i], false));
    FilteredPoints.push_back(cv::Point(mu[i].m10 / mu[i].m00, mu[i].m01 / mu[i].m00));

    cv::circle(PointFilterMat, FilteredPoints[i], 1, CvScalar(255, 255, 255), -1, 2, 0);
}

std::vector<std::vector<cv::Point>> FinalContourForWaterShed;
std::vector<cv::Vec4i> hierarchyForWatershed;//may need to change

cv::findContours(PointFilterMat, FinalContourForWaterShed, hierarchyForWatershed, cv::RETR_CCOMP, cv::CHAIN_APPROX_SIMPLE);

cv::Mat gray81 = cv::Mat::zeros(PointFilterMat.size(), CV_32SC1);

std::vector<cv::Moments> muForWatershed(PointFilterMatContours.size());
std::vector<cv::Point> FilteredPointsforWaterShed(PointFilterMatContours.size());

for (int i = 0; i < FinalContourForWaterShed.size(); i++) {
    muForWatershed.push_back(cv::moments(FinalContourForWaterShed[i], false));
    FilteredPointsforWaterShed.push_back(cv::Point(muForWatershed[i].m10 / muForWatershed[i].m00, muForWatershed[i].m01 / muForWatershed[i].m00));

    cv::circle(gray81, FilteredPointsforWaterShed[i], int(0.75), cv::Scalar::all(i+1), -1);

}

orginal.convertTo(orginal, CV_8UC3);

cv::cvtColor(orginal, orginal, cv::COLOR_GRAY2RGB);
std::string ty =  type2str( orginal.type() );
printf("Matrix: %sn", ty.c_str() );

gray81.convertTo(gray81, CV_32S);

cv::watershed(orginal, gray81);

gray81.convertTo(gray81, CV_8UC1);

UIImage *outputImg = MatToUIImage(gray81);

return outputImg;