/**
 * \brief Constructor.
 * \param img The image for the sprite.
 */
bear::visual::sprite::sprite( const image& img )
  : bitmap_rendering_attributes(img.size()), m_image(img),
    m_clip_rectangle(0, 0, img.width(), img.height()),
    m_opaque_rectangle( 0, 0, 0, 0 )
{

} // sprite::sprite()

static void image_insert_tile_row(image& target, int32_t x, int32_t y, uint32_t width, uint32_t height,
                                  const image& other, uint32_t offx, uint32_t offy)
{
	if (offx + width <= other.width)
	{
		target.insert_sub(x, y, other, offx, offy, width, height);
		return;
	}
	
	if (offx != 0)
	{
		target.insert_sub(x, y, other, offx, offy, other.width-offx, height);
		x += other.width-offx;
		width -= other.width-offx;
	}
	uint32_t xx = 0;
	if (width >= other.width)
	{
		for (xx = 0; xx < width-other.width; xx += other.width)
		{
			target.insert_sub(x+xx, y, other, 0, offy, other.width, height);
		}
	}
	if (xx < width)
	{
		target.insert_sub(x+xx, y, other, 0, offy, width-xx, height);
	}
}

            virtual BOOL on_draw(HELEMENT he, UINT draw_type, HDC hdc, const
                RECT &rc)
            {
                if ((DRAW_EVENTS)draw_type != where)
                    return FALSE;
                // do default draw
                int w = rc.right - rc.left;
                int h = rc.bottom - rc.top;
                if (!surface)
                {
                    surface = image::create(w, h);
                    redraw = true;
                }
                else if (w != surface->width() || h != surface->height())
                {
                    delete surface;
                    surface = image::create(w, h);
                    redraw = true;
                }
                else if (redraw)
                    surface->clear();

                if (redraw)
                {
                    graphics gx(surface);
                    draw(he, gx, w, h);
                    redraw = false;
                }
                surface->blit(hdc, rc.left, rc.top);

                return default_draw ? TRUE : FALSE;
            }

  // merge float channels
  bool mergeOCPToImage::apply(const matrix<float>& c1,
                              const matrix<float>& c2,
                              const matrix<float>& c3,
                              image& img) const {

    point p;              // coordinates
    float r,g,b;          // unnormed RGB channels
    float RG, BY, WB;     // opponent colour channels

    if ((c1.size() != c2.size()) || (c1.size() != c3.size())) {
      setStatusString("sizes of channels do not match");
      return false;
    }

    img.resize(c1.size(),rgbPixel(),false,false);

    for (p.y=0;p.y<img.rows();p.y++) {
      for (p.x=0;p.x<img.columns();p.x++) {

	RG = c1.at(p);
	BY = c2.at(p);
	WB = c3.at(p);

        b = BY*0.666666666667f;
        //
	r = WB + RG - b;
	g = WB - RG - b;
	b = WB + BY*1.3333333333333f;

	// truncate r,g and b if the value is not in intervall [0..1]
	// can happen due to rounding errors in split operation
	if (r<0.0f) {
          r=0.0f;
        } else if (r>1.0f) {
          r=1.0f;
        }

	if (g<0.0f) {
          g=0.0f;
        } else if (g>1.0f) {
          g=1.0f;
        }

	if (b<0.0f) {
          b=0.0f;
        } else if (b>1.0f) {
          b=1.0f;
        }

	img.at(p).set(static_cast<ubyte>(255.0f*r),
                      static_cast<ubyte>(255.0f*g),
                      static_cast<ubyte>(255.0f*b),
                      0);
      }
    }

    return true;
  };

/*!
 */
image  max(const image& lhs,const image& rhs)
{
  CvSize lhs_sz = lhs.dim();
  CvSize rhs_sz = rhs.dim();
  if((lhs_sz.height != rhs_sz.height) || (lhs_sz.width != rhs_sz.width)) throw exception();
  image res = lhs;
  cvMax(lhs,rhs,res);
  return res;
}

size_t cnt(const image& img) {
    size_t sum = 0;
    img.reset();
    while (img.move_next()) {
        if (img.element())
            sum++;
    }
    return sum;
}

image<vec4f> display_diff(const image<vec4f>& diff) {
    auto display = image{diff.size(), zero4f};
    for (auto j = 0; j < diff.size().y; j++) {
        for (auto i = 0; i < diff.size().x; i++) {
            auto diff_value = max(diff[{i, j}]);
            display[{i, j}] = {diff_value, diff_value, diff_value, 1};
        }
    }
    return display;
}

/*!
 */
image operator /(const image& lhs,const image& rhs)
{
  CvSize lhs_sz = lhs.dim();
  CvSize rhs_sz = rhs.dim(); 
  if((lhs_sz.width != rhs_sz.width) || (lhs_sz.height !=rhs_sz.height))
    throw exception();
  image result = lhs;
  cvDiv(lhs,rhs,result);
  return result;
}

	image_view::image_view(const image &image, const vk::Format format, vk::ImageAspectFlags aspectFlags)
		: device_(image.parent_device())
	{
		handle_ = device_.create_image_view(
			vk::ImageViewCreateInfo()
				.viewType(vk::ImageViewType::e2D)
				.format(format)
				.subresourceRange(vk::ImageSubresourceRange(aspectFlags, 0, 1, 0, 1))
				.image(image.handle()));
	}

void imshow_impl(
	const image<T1, D1>& im1, const char* title1,
	const image<T2, D2>& im2, const char* title2,
	const image<T3, D3>& im3, const char* title3,
	const image<T4, D4>& im4, const char* title4,
	const image<T5, D5>& im5, const char* title5)
{
	IplImage* ipl1;
	IplImage* ipl2;
	IplImage* ipl3;
	IplImage* ipl4;
	IplImage* ipl5;

	ipl1 = im1.ipl();
	cvNamedWindow(title1, 1);
	cvShowImage(title1, ipl1);

	if(title2) {
		ipl2 = im2.ipl();
		cvNamedWindow(title2, 2);
		cvShowImage(title2, ipl2);
	}

	if(title3) {
		ipl3 = im3.ipl();
		cvNamedWindow(title3, 3);
		cvShowImage(title3, ipl3);
	}

	if(title4) {
		ipl4 = im4.ipl();
		cvNamedWindow(title4, 4);
		cvShowImage(title4, ipl4);
	}

	if(title5) {
		ipl5 = im5.ipl();
		cvNamedWindow(title5, 5);
		cvShowImage(title5, ipl5);
	}

	cvWaitKey(0); // very important, contains event processing loop inside

	cvDestroyWindow(title1);
	if(title2) cvDestroyWindow(title2);
	if(title3) cvDestroyWindow(title3);
	if(title4) cvDestroyWindow(title4);
	if(title5) cvDestroyWindow(title5);

	cvReleaseImage(&ipl1);
	if(title2) cvReleaseImage(&ipl2);
	if(title3) cvReleaseImage(&ipl3);
	if(title4) cvReleaseImage(&ipl4);
	if(title5) cvReleaseImage(&ipl5);
}

typename image<T, D>::create_new median_blur(const image<T, D>& a, int neighbourhood)
{
	IplImage* src = a.ipl();
	IplImage* dst = cvCreateImage(cvGetSize(src),
		image_details::ipl_depth<T>(), int(a.channels()));
	cvSmooth(src, dst, CV_MEDIAN, neighbourhood);
	typename image<T, D>::create_new r(dst);
	cvReleaseImage(&src);
	cvReleaseImage(&dst);
	return r;
}

image<vec4f> compute_diff_image(const image<vec4f>& a, const image<vec4f>& b) {
    auto diff = image{a.size(), zero4f};
    for (auto j = 0; j < a.size().y; j++) {
        for (auto i = 0; i < a.size().x; i++) {
            diff[{i, j}] = {abs(a[{i, j}].x - b[{i, j}].x),
                abs(a[{i, j}].y - b[{i, j}].y), abs(a[{i, j}].z - b[{i, j}].z),
                abs(a[{i, j}].w - b[{i, j}].w)};
        }
    }
    return diff;
}

void find_in_image() {
	Setting conf("application.cfg");
	string base = conf.getString("application.res_dir");
	Mat haystack = read(base + "/car_features/01.jpg");
	Mat needle = toGrayscale(cv::imread(base + "/car_features/01.jpg"));
	Mat needle64x128;
	cv::resize(needle, needle64x128, Size(64, 128));

	vector<float> hog = computeHog(needle64x128);

	cout << hog.size() << endl;
}

typename image<T, D>::create_new laplace(const image<T, D>& a,
	int aperture_size)
{
	IplImage* src = a.ipl();
	IplImage* dst = cvCreateImage(cvGetSize(src),
		image_details::ipl_depth<T>(), int(a.channels()));
	cvLaplace(src, dst, aperture_size);
	typename image<T, D>::create_new r(dst);
	cvReleaseImage(&src);
	cvReleaseImage(&dst);
	return r;
}

typename image<T, D>::create_new blur_no_scale(const image<T, D>& a, int neighbourhood_rows,
	int neighbourhood_cols)
{
	IplImage* src = a.ipl();
	IplImage* dst = cvCreateImage(cvGetSize(src),
		image_details::ipl_depth<T>(), int(a.channels()));
	cvSmooth(src, dst, CV_BLUR_NO_SCALE, neighbourhood_cols, neighbourhood_rows);
	typename image<T, D>::create_new r(dst);
	cvReleaseImage(&src);
	cvReleaseImage(&dst);
	return r;
}

typename image<T, D>::create_new sobel(const image<T, D>& a,
	int y_order, int x_order, int aperture_size)
{
	IplImage* src = a.ipl();
	IplImage* dst = cvCreateImage(cvGetSize(src),
		image_details::ipl_depth<T>(), (int)a.channels());
	cvSobel(src, dst, x_order, y_order, aperture_size);
	typename image<T, D>::create_new r(dst);
	cvReleaseImage(&src);
	cvReleaseImage(&dst);
	return r;
}

typename image<T, D>::create_new pyramid_down(const image<T, D>& a)
{
	IplImage* src = a.ipl();
	IplImage* dst = cvCreateImage(
		image_details::cv_size(a.width() / 2, a.height() / 2),
		image_details::ipl_depth<T>(), int(a.channels()));
	cvPyrDown(src, dst);
	typename image<T, D>::create_new r(dst);
	cvReleaseImage(&src);
	cvReleaseImage(&dst);
	return r;
}

image image::operator/(const image& img) const
{
  // sanity check
  assert(width() == img.width() && height() == img.height());

  // create result
  image result(width(), height());
  std::transform(begin(), end(), img.begin(), result.begin(), std::divides<color>());

  // Done.
  return result;
}

typename image<T, D>::create_new bilateral_blur(const image<T, D>& a, int color_sigma,
	int space_sigma)
{
	IplImage* src = a.ipl();
	IplImage* dst = cvCreateImage(cvGetSize(src),
		image_details::ipl_depth<T>(), int(a.channels()));
	cvSmooth(src, dst, CV_BILATERAL, color_sigma, space_sigma);
	typename image<T, D>::create_new r(dst);
	cvReleaseImage(&src);
	cvReleaseImage(&dst);
	return r;
}

void image::insert_image(Pos& pos, image& image_to_insert) {
	// Check dimensions
	if (pos.x + image_to_insert.size().width > this->size_.width ||
	    pos.y + image_to_insert.size().height > this->size_.height) {
		cout << "Cant insert image: Size mismatch!" << endl;
		return;
	}

	for (int y = 0; y < image_to_insert.size().height; ++y)
		for (int x = 0; x < image_to_insert.size().width; ++x) 
			this->pixels_[y + pos.y][x + pos.x] = image_to_insert.pixels().at(y).at(x);
		
}