//
//  PairMarkCorrelation.cpp
//  
//
//  Created by Arne Pommerening on 10/24/13.
//  Copyright 2013 Philodendron International. All rights reserved.
//

#include <Rcpp.h>
#include <cmath>
#include <ctime>
using namespace Rcpp;
using namespace std;


/**
 * Estimates the pair and mark correlation and the L function.
 */
// [[Rcpp::export]]
DataFrame calcPairMark(DataFrame TreeList, double xmax, double ymax, int m, double dd, double h, double mdbh, int kernel) {
	vector<double> x = as< vector<double> > (TreeList["x"]);
    vector<double> y = as< vector<double> > (TreeList["y"]);
    vector<double> dbh = as< vector<double> > (TreeList["dbh"]);
    const double pi = 4.0 * atan(1.0);
    int n = dbh.size();
    double la = n / (xmax * ymax);
    double ql = la * la;
	NumericVector g(m), xm(m), r(m), xl(m), xk(m);
    for(int i = 0; i < m; i++) {
        g[i] = 0;
        xk[i] = 0;
        xm[i] = 0;
        //xv[i] = 0;
        xl[i] = 0;
		r[i] = 0;
    }
    double rz = m * dd + h;
    for(int i = 1; i < n; i++) {
        double xx = x[i];
        double yy = y[i];
        double zz = dbh[i];
        for(int j = 0; j < i; j++) {
            double cx = fabs(xx - x[j]);
            if(cx < rz) {
                double cy = fabs(yy - y[j]);
                if(cy < rz) {
                    double tz = sqrt(cx * cx + cy * cy);
                    if(tz < rz) {
                        double cc = 1 / ((xmax - cx) * (ymax - cy));
                        for(int l = 0; l < m; l++) {
                            double xr = (l + 1) * dd;
                            if(tz <= xr) {
								xk[l] += 2 * cc; 
								// xl[l] += 2 * cc * pow(zz - dbh[j], 2) * 0.5; 
								xl[l] += 2 * cc * zz * dbh[j]; 
							}
							double t = fabs(xr - tz);
                            if(t <= h) {
                                double rh = 0;
                                if(kernel == 0)
                                  rh = (1 - pow(t / h, 2)) * 0.75 / h;
                                else
                                  rh = 0.5 / h;
                                double cr = pi * xr;
                                rh *= cc / cr;
                                g[l] += rh;
                                xm[l] += rh * zz * dbh[j]; 
                                //xv[l] += rh * pow(zz - dbh[j], 2) * 0.5;
                            }
                        }
                    }
                }
            }    
        }
    }
    for(int l = 0; l < m; l++) {
		r[l] = (l + 1) * dd; 
		xk[l] = sqrt(xk[l] / (pi * ql));
        xl[l] = sqrt(xl[l] / (pi * ql * mdbh * mdbh));
        if(g[l] < 1E-20)
            xm[l] = -1;
        else
            xm[l] /= g[l] * mdbh * mdbh;
		g[l] /= ql;
    }
    return DataFrame::create(Named("r") = r, Named("g") = g, Named("L") = xk, Named("k") = xm, Named("Lk") = xl);
}

/**
 * Calculates the minimum distance between points in an observation window.
 */
// [[Rcpp::export]]
double calcMinDistance(NumericVector x, NumericVector y) {
	double dm = 1E50;
	double xx = 0;
    int n = x.size();
    for(int i = 1; i < n; i++) {
        for(int j = 0; j < i; j++) {
			xx = pow(x[i] - x[j], 2) + pow(y[i] - y[j], 2);
			dm = min(xx, dm);
		}
	}
	return sqrt(dm);
}