void setLayerSizes( InputArray _layer_sizes )
{
clear();
_layer_sizes.copyTo(layer_sizes);
int l_count = layer_count();
weights.resize(l_count + 2);
max_lsize = 0;
if( l_count > 0 )
{
for( int i = 0; i < l_count; i++ )
{
int n = layer_sizes[i];
if( n < 1 + (0 < i && i < l_count-1))
CV_Error( CV_StsOutOfRange,
"there should be at least one input and one output "
"and every hidden layer must have more than 1 neuron" );
max_lsize = std::max( max_lsize, n );
if( i > 0 )
weights[i].create(layer_sizes[i-1]+1, n, CV_64F);
}
int ninputs = layer_sizes.front();
int noutputs = layer_sizes.back();
weights[0].create(1, ninputs*2, CV_64F);
weights[l_count].create(1, noutputs*2, CV_64F);
weights[l_count+1].create(1, noutputs*2, CV_64F);
}
}
void drawKeypoints( InputArray image, const std::vector<KeyPoint>& keypoints, InputOutputArray outImage,
const Scalar& _color, DrawMatchesFlags flags )
{
CV_INSTRUMENT_REGION();
if( !(flags & DrawMatchesFlags::DRAW_OVER_OUTIMG) )
{
if (image.type() == CV_8UC3 || image.type() == CV_8UC4)
{
image.copyTo(outImage);
}
else if( image.type() == CV_8UC1 )
{
cvtColor( image, outImage, COLOR_GRAY2BGR );
}
else
{
CV_Error( Error::StsBadArg, "Incorrect type of input image: " + typeToString(image.type()) );
}
}
RNG& rng=theRNG();
bool isRandColor = _color == Scalar::all(-1);
CV_Assert( !outImage.empty() );
std::vector<KeyPoint>::const_iterator it = keypoints.begin(),
end = keypoints.end();
for( ; it != end; ++it )
{
Scalar color = isRandColor ? Scalar( rng(256), rng(256), rng(256), 255 ) : _color;
_drawKeypoint( outImage, *it, color, flags );
}
}
void cv::superres::arrCopy(InputArray src, OutputArray dst)
{
if (dst.isUMat() || src.isUMat())
{
src.copyTo(dst);
return;
}
typedef void (*func_t)(InputArray src, OutputArray dst);
static const func_t funcs[10][10] =
{
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, arr2buf, 0, mat2gpu },
{ 0, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, arr2buf, 0, mat2gpu },
{ 0, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, arr2buf, 0, mat2gpu },
{ 0, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, arr2buf, 0, mat2gpu },
{ 0, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, arr2buf, 0, mat2gpu },
{ 0, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, arr2buf, 0, mat2gpu },
{ 0, buf2arr, buf2arr, buf2arr, buf2arr, buf2arr, buf2arr, buf2arr, 0, buf2arr },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, gpu2mat, gpu2mat, gpu2mat, gpu2mat, gpu2mat, gpu2mat, arr2buf, 0 , gpu2gpu },
};
const int src_kind = src.kind() >> _InputArray::KIND_SHIFT;
const int dst_kind = dst.kind() >> _InputArray::KIND_SHIFT;
CV_Assert( src_kind >= 0 && src_kind < 10 );
CV_Assert( dst_kind >= 0 && dst_kind < 10 );
const func_t func = funcs[src_kind][dst_kind];
CV_Assert( func != 0 );
func(src, dst);
}
void IPPE::PoseSolver::solveSquare(float squareLength, InputArray _imagePoints, InputArray _cameraMatrix, InputArray _distCoeffs,
OutputArray _rvec1, OutputArray _tvec1, float& err1, OutputArray _rvec2, OutputArray _tvec2, float& err2)
{
//allocate outputs:
_rvec1.create(3, 1, CV_64FC1);
_tvec1.create(3, 1, CV_64FC1);
_rvec2.create(3, 1, CV_64FC1);
_tvec2.create(3, 1, CV_64FC1);
cv::Mat normalizedInputPoints; //undistored version of imagePoints
cv::Mat objectPoints2D;
//generate the object points:
generateSquareObjectCorners2D(squareLength, objectPoints2D);
cv::Mat H; //homography from canonical object points to normalized pixels
if (_cameraMatrix.empty()) {
//this means imagePoints are defined in normalized pixel coordinates, so just copy it:
_imagePoints.copyTo(normalizedInputPoints);
}
else {
//undistort the image points (i.e. put them in normalized pixel coordinates).
cv::undistortPoints(_imagePoints, normalizedInputPoints, _cameraMatrix, _distCoeffs);
}
//compute H
homographyFromSquarePoints(normalizedInputPoints, squareLength / 2.0f, H);
//now solve
cv::Mat Ma, Mb;
solveCanonicalForm(objectPoints2D, normalizedInputPoints, H, Ma, Mb);
//sort poses according to reprojection error:
cv::Mat M1, M2;
cv::Mat objectPoints3D;
generateSquareObjectCorners3D(squareLength, objectPoints3D);
sortPosesByReprojError(objectPoints3D, _imagePoints, _cameraMatrix, _distCoeffs, Ma, Mb, M1, M2, err1, err2);
//fill outputs
rot2vec(M1.colRange(0, 3).rowRange(0, 3), _rvec1);
rot2vec(M2.colRange(0, 3).rowRange(0, 3), _rvec2);
M1.colRange(3, 4).rowRange(0, 3).copyTo(_tvec1);
M2.colRange(3, 4).rowRange(0, 3).copyTo(_tvec2);
}
static void _prepareImage(InputArray src, const Mat& dst)
{
CV_CheckType(src.type(), src.type() == CV_8UC1 || src.type() == CV_8UC3 || src.type() == CV_8UC4, "Unsupported source image");
CV_CheckType(dst.type(), dst.type() == CV_8UC3 || dst.type() == CV_8UC4, "Unsupported destination image");
const int src_cn = src.channels();
const int dst_cn = dst.channels();
if (src_cn == dst_cn)
src.copyTo(dst);
else if (src_cn == 1)
cvtColor(src, dst, dst_cn == 3 ? COLOR_GRAY2BGR : COLOR_GRAY2BGRA);
else if (src_cn == 3 && dst_cn == 4)
cvtColor(src, dst, COLOR_BGR2BGRA);
else if (src_cn == 4 && dst_cn == 3)
cvtColor(src, dst, COLOR_BGRA2BGR);
else
CV_Error(Error::StsInternal, "");
}
static bool ocl_flip(InputArray _src, OutputArray _dst, int flipCode )
{
int type = _src.type(), cn = CV_MAT_CN(type);
if (cn > 4 || cn == 3)
return false;
const char * kernelName;
int flipType;
if (flipCode == 0)
kernelName = "arithm_flip_rows", flipType = FLIP_ROWS;
else if (flipCode > 0)
kernelName = "arithm_flip_cols", flipType = FLIP_COLS;
else
kernelName = "arithm_flip_rows_cols", flipType = FLIP_BOTH;
Size size = _src.size();
int cols = size.width, rows = size.height;
if ((cols == 1 && flipType == FLIP_COLS) ||
(rows == 1 && flipType == FLIP_ROWS) ||
(rows == 1 && cols == 1 && flipType == FLIP_BOTH))
{
_src.copyTo(_dst);
return true;
}
ocl::Kernel k(kernelName, ocl::core::flip_oclsrc,
format( "-D type=%s", ocl::memopTypeToStr(type)));
if (k.empty())
return false;
_dst.create(size, type);
UMat src = _src.getUMat(), dst = _dst.getUMat();
cols = flipType == FLIP_COLS ? ((cols+1)/2) : cols;
rows = flipType & FLIP_ROWS ? ((rows+1)/2) : rows;
size_t globalsize[2] = { cols, rows };
return k.args(ocl::KernelArg::ReadOnlyNoSize(src), ocl::KernelArg::WriteOnly(dst), rows, cols).run(2, globalsize, NULL, false);
}
Textons::Textons(int DictionarySize, InputArray input_image):
k(DictionarySize) {
input_image.copyTo(test_image);
}
void BagOfWordsSlic::GenerateSuperpixels(Mat _edges, InputArray _input_image, OutputArray _superpixels,
int _number_of_superpixels, InputArray _visual_word_map,
InputArray _mask, OutputArray _superpixel_centroids) {
cout << "generating super pixels" << endl;
/*--Convert from input arguments to class data-structures--*/
input_image_ = _input_image.getMat();
Mat visual_word_map = _visual_word_map.getMat();
Mat mask = _mask.getMat();
cvtColor(mask, mask, CV_BGR2GRAY);
im_height_ = input_image_.rows;
im_width_ = input_image_.cols;
num_superpixels_ = _number_of_superpixels;
// Compute step size
S_ = sqrt(im_height_*im_width_/num_superpixels_);
/*--Get Lab Image--*/
Mat lab_image(input_image_.size(), CV_8UC3);
cvtColor(input_image_, lab_image, COLOR_BGR2Lab);
/*--Initialize centroid locations to regular grid with computed step size--*/
int grid_width = ceil((float)im_width_/S_);
int grid_height = ceil((float)im_height_/S_);
num_superpixels_ = grid_width*grid_height;
image_oversegmentation_ = new Oversegmentation(input_image_);
cluster_centroids_.resize(num_superpixels_);
int index_cluster = 0;
for(int i = 0; i < cluster_centroids_.size(); ++i) {
int offset = 0;
if (((i-1)/grid_width)%2 == 0)
offset = S_/4;
else
offset = 3*S_/4;
int x = offset + ((i-1)%grid_width)*S_;
int y = offset + ((i-1)/grid_width)*S_;
int s_ = ceil((float)S_/2);
if ((int)(mask.at<uchar>(y,x)) == 1
&& mask.at<uchar>(min(y+s_, im_height_),min(x+s_, im_width_)) == 1
&& mask.at<uchar>(max(y-s_, 0), max(x-s_,0)) ==1
&& mask.at<uchar>(max(y-s_, 0), min(x+s_, im_width_))==1
&& mask.at<uchar>(min(y+s_, im_height_), max(x-s_, 0))==1) {
// cluster_centroids_[i].pt_.x = offset + ((i-1)%grid_width)*S_;
// cluster_centroids_[i].pt_.y = offset + ((i-1)/grid_width)*S_;
cluster_centroids_[i].pt_.x = x;
cluster_centroids_[i].pt_.y = y;
}
index_cluster++;
}
// Find local minimum of gradient magnitude and adjust centroid locations
MoveCentroidsToLocalGradientMinima();
for(int i = 0; i < cluster_centroids_.size(); ++i)
image_oversegmentation_->AddNewSegmentAt(cluster_centroids_[i].pt_);
if (visual_word_map.empty()) {
visual_word_histogram_matrix_.create(input_image_.size(),CV_64FC(KCENTERS));
} else {
//Compute visual_word histograms
ComputeVisualWordHistograms(5,5,visual_word_map);
}
/*---Generate descriptors at centroid locations---*/
// Get L,A,B vector for each centroid
for(int i = 0; i < cluster_centroids_.size(); ++i) {
cluster_centroids_[i].lab_color_ = lab_image.at<Vec3b>(image_oversegmentation_->SegmentCentroid(i));
cluster_centroids_[i].visual_word_histogram_ = visual_word_histogram_matrix_.at<Vec50d>(image_oversegmentation_->SegmentCentroid(i));
}
/*--Initialize distance to nearest centroid for each pixel--*/
distance_matrix_.create(input_image_.size(), CV_64F);
double dist;
int* superpixel_label_matrix_row;
Vec50d* visual_word_histogram_row;
double* distance_matrix_row;
Vec3b* lab_image_row;
/*---First loop starts: for iter = 1 to kMaxIter---*/
for(int iter = 0; iter < kMaxIter; ++iter) {
/* Reset distances */
distance_matrix_.setTo(DBL_MAX);
cout << "EM iteration: " << iter << "\n";
cout << "Number of segments now: " << image_oversegmentation_->NumberOfSegments() << "\n";
int x_lower_limit, x_upper_limit, y_lower_limit, y_upper_limit;
/*---Second loop starts: for cInd = 1 to num_superpixels_---*/
for(int i = 0; i < num_superpixels_; ++i) {
int centroid_x = cluster_centroids_[i].pt_.x, centroid_y = cluster_centroids_[i].pt_.y;
/*---Third loop starts: Iterate through each pixel in 2S+1 x 2S+1 window size around centroid[i]---*/
y_lower_limit = max(centroid_y - S_,0);
y_upper_limit = min(centroid_y + S_,im_height_);
x_lower_limit = max(centroid_x - S_,0);
x_upper_limit = min(centroid_x + S_,im_width_);
for(int pixel_y = y_lower_limit; pixel_y < y_upper_limit; pixel_y++) {
lab_image_row = lab_image.ptr<Vec3b>(pixel_y);
distance_matrix_row = distance_matrix_.ptr<double>(pixel_y);
visual_word_histogram_row = visual_word_histogram_matrix_.ptr<Vec50d>(pixel_y);
superpixel_label_matrix_row = image_oversegmentation_->pixel_labels_.ptr<int>(pixel_y);
int temp_x = x_lower_limit;
for(int pixel_x = x_lower_limit; pixel_x < x_upper_limit; ++pixel_x) {
if (mask.at<uchar>(pixel_y, pixel_x) != 1)
continue;
//Compute the pixel's distance to centroid[i]
ClusterPoint pixel(Point2f(pixel_x,pixel_y), lab_image_row[pixel_x], visual_word_histogram_row[pixel_x]);
if (visual_word_map.empty()) {
dist = cluster_centroids_[i].distance_to(pixel, m_, S_, 0);
} else {
dist = cluster_centroids_[i].distance_to(pixel, m_, S_, kHistogramDistanceWeight);
}
/*---Update the superpixel[pixel] and distance[pixel] if required---*/
if(dist < distance_matrix_row[pixel_x]) {
distance_matrix_row[pixel_x] = dist;
superpixel_label_matrix_row[pixel_x] = i;
}
}
}
/*---Third loop ends---*/
}/*---Second loop ends---*/
image_oversegmentation_->ComputeSegmentAreas();
//Create vector of flags to indicate discardedsuperpixel_labels
vector<bool> discard_list(num_superpixels_,false);
/*---Fourth loop: iterate through each centroid(superpixel) and count number of pixels within.
If count is too small, mark superpixel for discarding---*/
for(int i = 0; i < num_superpixels_; ++i) {
if (discard_list[i] != 1) {
discard_list[i] = image_oversegmentation_->SegmentArea(i) < kMinSuperpixelAreaThreshold;
}
}
int num_discarded = 0;
for(int i = 0; i < discard_list.size(); ++i)
if(discard_list[i])
++num_discarded;
image_oversegmentation_->DeleteSegments(discard_list);
num_superpixels_ = image_oversegmentation_->NumberOfSegments();
vector<Point> old_centroids = image_oversegmentation_->GetCentroids();
UpdateClusterCentroids(lab_image);
vector<Point> new_centroids = image_oversegmentation_->GetCentroids();
/*---Check for convergence - if converged, then break from loop---*/
int max_centroid_displacement = -1;
for(int i = 0; i < num_superpixels_ ; ++i) {
int x_difference = abs(old_centroids[i].x-new_centroids[i].x);
int y_difference = abs(old_centroids[i].y-new_centroids[i].y);
max_centroid_displacement = std::max(max_centroid_displacement,x_difference);
max_centroid_displacement = std::max(max_centroid_displacement,y_difference);
}
cout << "max distance: " << max_centroid_displacement << "\n";
if (max_centroid_displacement <= kCentroidErrorThreshold) {
RenumberEachConnectedComponent();
RelabelSmallSegmentsToNearestNeighbor(kMinSuperpixelAreaThreshold);
cout << "Number of segments now: " << image_oversegmentation_->NumberOfSegments() << "\n";
break;
}
/*---First loop ends---*/
}
image_oversegmentation_->pixel_labels_.copyTo(_superpixels);
vector<Point> centroids = image_oversegmentation_->GetCentroids();
_superpixel_centroids.create(centroids.size(), 2, CV_32S);
Mat superpixel_centroids = _superpixel_centroids.getMat();
for (int i = 0; i < centroids.size(); ++i) {
superpixel_centroids.at<int>(i,0) = centroids[i].x;
superpixel_centroids.at<int>(i,1) = centroids[i].y;
}
_input_image.copyTo(image_oversegmentation_->_original_image);
visual_word_map.copyTo(image_oversegmentation_->Texton_image);
_edges.copyTo(image_oversegmentation_->_edges);
image_oversegmentation_->ListPixelsForEachSegment();
// Mat src = _input_image.getMat();
//cout << "where2" << endl;
// image_oversegmentation_->ComputeSegmentFeatures(src, visual_word_map, _edges);
image_oversegmentation_->ShowClassifiedLabelImage(mask);
cout << "where3" << endl;
// cout << "total num superpixels: " << centroids.size() << endl;
// _number_of_superpixels_total = centroids.size();
return;
/*---Clean up image_oversegmentation_->pixel_labels_---*/
}
