double
CQIllustratorShape::
distance(const CPoint2D &p) const
{
const CBBox2D &bbox = getFlatBBox();
const CPoint2D &p1 = bbox.getLL();
const CPoint2D &p2 = bbox.getUR();
if (p.x < p1.x) {
if (p.y < p1.y) return pointDist(p, CPoint2D(p1.x, p1.y));
else if (p.y > p2.y) return pointDist(p, CPoint2D(p1.x, p2.y));
else return (p1.x - p.x);
}
else if (p.x > p2.x) {
if (p.y < p1.y) return pointDist(p, CPoint2D(p2.x, p1.y));
else if (p.y > p2.y) return pointDist(p, CPoint2D(p2.x, p2.y));
else return (p.x - p2.x);
}
else {
if (p.y < p1.y) return (p1.y - p.y);
else if (p.y > p2.y) return (p.y - p2.y);
else return 0;
}
}
// computes distance between two parallel lines
double IntersectionRectangle::parallelDist(const DLine& d1, const DLine& d2) const
{
OGDF_ASSERT((d1.isHorizontal() && d2.isHorizontal()) ||
(d1.isVertical() && d2.isVertical()));
double d1min, d1max, d2min, d2max, paraDist, dist;
if(d1.isVertical()) {
d1min = d1.start().m_y;
d1max = d1.end().m_y;
d2min = d2.start().m_y;
d2max = d2.end().m_y;
paraDist = fabs(d1.start().m_x - d2.start().m_x);
}
else {
d1min = d1.start().m_x;
d1max = d1.end().m_x;
d2min = d2.start().m_x;
d2max = d2.end().m_x;
paraDist = fabs(d1.start().m_y - d2.start().m_y);
}
if(d1min > d1max) swap(d1min,d1max);
if(d2min > d2max) swap(d2min,d2max);
if(d1min > d2max || d2min > d1max) { // no overlap
dist = pointDist(d1.start(),d2.start());
dist = min(dist,pointDist(d1.start(),d2.end()));
dist = min(dist,pointDist(d1.end(),d2.start()));
dist = min(dist,pointDist(d1.end(),d2.end()));
}
else
dist = paraDist; // segments overlap
return dist;
}
/*
compute the inner product of the vectors, (n+, n-)
*/
double innerProduct(tVertex site, tVertex pole, tVertex v) {
double dist1, dist2;
double angle = 0.0;
double result = 0.0;
dist1 = pointDist(site, pole);
dist2 = pointDist(site, v);
angle = getAngle(pole, v);
result = dist1 * dist2* cos(angle);
return result;
}
float World::getClosestPlayer(const std::vector<Client *> &clients,
int x, int y) const
{
Vector2f pos;
Vector2i chunkId;
float distance;
float closest = -1.f;
ClientEntity clEnt;
// Going up makes the Y indice increment
x += Chunk::width / 2;
y -= Chunk::height / 2;
for (const auto cl : clients)
{
if (!cl->isInitialized())
continue ;
clEnt = cl->getEntity();
pos = clEnt.getPosition();
chunkId = clEnt.getChunkId();
chunkId.x *= Chunk::width;
chunkId.y *= Chunk::height;
pos = Vector2f(chunkId.x + pos.x * Chunk::width,
chunkId.y - pos.y * Chunk::height);
distance = pointDist(std::abs(pos.x - x), std::abs(pos.y - y));
if (closest == -1 || distance < closest)
closest = distance;
}
return closest;
}
unsigned int World::removeUnusedChunks(const Vector2i &entId,
const std::vector<Client *> &clients)
{
unsigned int counter = 0;
_loadedChunks.erase(std::remove_if(_loadedChunks.begin(), _loadedChunks.end(),
[&](Chunk *chunk)
{
Vector2i pos(chunk->getPosition());
bool removed;
float distance;
distance = pointDist(std::abs(pos.x - entId.x) * Chunk::width,
std::abs(pos.y - entId.y) * Chunk::height);
distance = std::min(getClosestPlayer(clients,
pos.x * Chunk::width,
pos.y * Chunk::height),
distance);
removed = (distance >= World::removeDist);
counter += removed;
if (removed)
std::cout << "remove " << pos.x << " " << pos.y << std::endl;
return removed;
}), _loadedChunks.end());
return counter;
}
float ConstrainedFire::TriangleArea(int p1, int p2, int p3)
{
Point3f point1,point2,point3;
float a,b,c,s;
point1 = m_Vertices[p1].position;
point2 = m_Vertices[p2].position;
point3 = m_Vertices[p3].position;
a = pointDist(point1,point2); //三角形的边长
b = pointDist(point2,point3);
c = pointDist(point3,point1);
s = (a+b+c)*0.5; //周长的一半
return sqrt(s*(s-a)*(s-b)*(s-c)); //计算面积
}
IplImage* cutSign(IplImage* origImg, CvPoint* corners, int numcorners, bool drawcircles)
{
// convert corners to CvPoint2D32f.
CvPoint2D32f cornersf[numcorners];
for (int i=0; i<numcorners; ++i)
cornersf[i] = cvPointTo32f(corners[i]);
if (_debug) printf("Corners: %d,%d %d,%d %d,%d %d,%d\n",corners[0].x,corners[0].y,corners[1].x,corners[1].y,corners[2].x,corners[2].y,corners[3].x,corners[3].y);
// Create target-image with right size.
double xDiffBottom = pointDist(corners[0], corners[1]);
double yDiffLeft = pointDist(corners[0], corners[3]);
IplImage* cut = cvCreateImage(cvSize(xDiffBottom,yDiffLeft), IPL_DEPTH_8U, 3);
// target points for perspective correction.
CvPoint2D32f cornerstarget[numcorners];
cornerstarget[0] = cvPoint2D32f(0,0);
cornerstarget[1] = cvPoint2D32f(cut->width-1,0);
cornerstarget[2]= cvPoint2D32f(cut->width-1,cut->height-1);
cornerstarget[3] = cvPoint2D32f(0,cut->height-1);
if (_debug) printf("Corners: %f,%f %f,%f %f,%f %f,%f\n",cornerstarget[0].x,cornerstarget[0].y,cornerstarget[1].x,cornerstarget[1].y,cornerstarget[2].x,cornerstarget[2].y,cornerstarget[3].x,cornerstarget[3].y);
// Apply perspective correction to the image.
CvMat* transmat = cvCreateMat(3, 3, CV_32FC1); // Colums, rows ?
transmat = cvGetPerspectiveTransform(cornersf,cornerstarget,transmat);
cvWarpPerspective(origImg,cut,transmat);
cvReleaseMat(&transmat);
// Draw yellow circles around the corners.
if (drawcircles)
for (int i=0; i<numcorners; ++i)
cvCircle(origImg, corners[i],5,CV_RGB(255,255,0),2);
return cut;
}
void findPoleAntiPole(int vsize) {
tVertex site;
double *pole_vector;
double avg_normal[3] = { 0, };
facetT *neighbor, **neighborp;
tVertex pole_voronoi_vertex = NULL;
tVertex antipole_voronoi_vertex = NULL;
vertexT *temp_voronoi_vertexT = NULL;
tVertex temp_voronoi_vertex;
tList site_voronoi_vertices;
double temp_dist = 0;
double max_dist = 0;
int neighbor_size = 0;
int i;
tVertex temp_vertex;
tVertex temp_vertices;
int is_on_convexhull = 0;
temp_vertex = vertices;
temp_vertices = vertices;
site = vertices;
// for all vertices
do {
site_voronoi_vertices = site->vvlist;
if (!site_voronoi_vertices) {
temp_vertex = temp_vertex->next;
site = site->next;
continue;
}
temp_voronoi_vertexT = (vertexT*)site_voronoi_vertices->p;
if (!temp_voronoi_vertexT) { // lies on the CH: compute the average of the outer nomals of the adjacents.
pole_vector = (double *)calloc(3, sizeof(double));
neighbor_size = 0;
FOREACHneighbor_(temp_voronoi_vertexT) {
neighbor_size++;
avg_normal[X] += neighbor->normal[X];
avg_normal[Y] += neighbor->normal[Y];
avg_normal[Z] += neighbor->normal[Z];
}
avg_normal[X] /= neighbor_size;
avg_normal[Y] /= neighbor_size;
avg_normal[Z] /= neighbor_size;
for (i = 0; i < 3; i++) {
pole_vector[i] = avg_normal[i];
}
is_on_convexhull = TRUE;
}
else {
site_voronoi_vertices = site->vvlist;
do { // Find the farthest Voronoi vertex from s.
temp_voronoi_vertex = (tVertex)(site_voronoi_vertices->p);
temp_dist = pointDist(site, temp_voronoi_vertex);
if (temp_dist > max_dist) {
pole_voronoi_vertex = temp_voronoi_vertex;
max_dist = temp_dist;
}
} while (site_voronoi_vertices != site->vvlist);
if (pole_voronoi_vertex){
if (max_dist > MAX_DIST) {
pole_voronoi_vertex = NULL;
}
else {
pole_voronoi_vertex->ispole = TRUE;
pole_voronoi_vertex->vnum = vsize++;
ADD(vertices, pole_voronoi_vertex);
pole_vector = (double *)calloc(3, sizeof(double));
for (i = 0; i < 3; i++) {
pole_vector[i] = pole_voronoi_vertex->v[i];
}
}
}
}
max_dist = 0;
temp_dist = 0;
// find a antipole
site_voronoi_vertices = site->vvlist;
if (pole_voronoi_vertex != NULL) {
do {
temp_voronoi_vertex = (tVertex)(site_voronoi_vertices->p);
if (temp_voronoi_vertex->ispole) {
continue;
}
temp_dist = innerProduct(site, pole_voronoi_vertex, temp_voronoi_vertex);
if (temp_dist > max_dist) {
antipole_voronoi_vertex = temp_voronoi_vertex;
max_dist = temp_dist;
}
site_voronoi_vertices = site_voronoi_vertices->next;
} while (site_voronoi_vertices != site->vvlist);
}
else if (is_on_convexhull) { // the site is on CH
do {
temp_voronoi_vertex = (tVertex)(site_voronoi_vertices->p);
tVertex temp_vertex = MakeTempVertex(pole_vector);
temp_dist = innerProduct(site, temp_vertex, temp_voronoi_vertex);
if (temp_dist > max_dist) {
antipole_voronoi_vertex = temp_voronoi_vertex;
max_dist = temp_dist;
}
site_voronoi_vertices = site_voronoi_vertices->next;
} while (site_voronoi_vertices != site->vvlist);
}
if (antipole_voronoi_vertex){
if (max_dist > MAX_DIST) {
antipole_voronoi_vertex = NULL;
}
else {
antipole_voronoi_vertex->ispole = TRUE;
antipole_voronoi_vertex->vnum = vsize++;
ADD(vertices, antipole_voronoi_vertex);
}
}
max_dist = 0;
avg_normal[0] = 0;
avg_normal[1] = 0;
avg_normal[2] = 0;
pole_vector = NULL;
pole_voronoi_vertex = NULL;
antipole_voronoi_vertex = NULL;
is_on_convexhull = FALSE;
temp_vertex = temp_vertex->next;
site = site->next;
} while (temp_vertex != temp_vertices);
void SubPixelCorner::RefineCorner(cv::Mat image, std::vector< cv::Point2f > &corners) {
if (enable == false)
return;
checkTerm();
generateMask();
// loop over all the corner points
for (int k = 0; k < corners.size(); k++) {
cv::Point2f curr_corner;
// initial estimate
cv::Point2f estimate_corner = corners[k];
// cerr << 'SSS" << corners[k].x <<":" << corners[k].y << endl;
if (estimate_corner.x < 0 || estimate_corner.y < 0 || estimate_corner.y > image.rows || estimate_corner.y > image.cols)
continue;
int iter = 0;
double dist = TermCriteria::EPS;
// loop till termination criteria is met
do {
iter = iter + 1;
curr_corner = estimate_corner;
/*
Point cx;
cx.x=floor(curr_corner.x);
cx.y=floor(curr_corner.y);
double dx=curr_corner.x-cx.x;
double dy=curr_corner.y-cx.y;
float vIx[2];
float vIy[2];
vIx[0] = dx;
vIx[1] = 1 - dx;
vIy[0] = dy;
vIy[1] = 1 - dy;
int x1=std::max((int)(cx.x-_winSize-_apertureSize/2),0);
int y1=std::max((int)(cx.y-_winSize-_apertureSize/2),0);
xmin = x1<0?0:x1;
xmax = x1+_winSize<image.cols?x1+_winSize:image.cols-1;
ymin = y1<0?0:y1;
ymax = y1+_winSize<image.rows?y1+_winSize:image.rows-1;
Rect roi=Rect(xmin,ymin,xmax-xmin,ymax-ymin);
*/
Mat local;
cv::getRectSubPix(image, Size(_winSize + 2 * (_apertureSize / 2), _winSize + 2 * (_apertureSize / 2)), curr_corner, local);
cv::Mat Dx, Dy;
// extracing image ROI about the corner point
// Mat local=image(roi);
// computing the gradients over the neighborhood about corner point
cv::Sobel(local, Dx, CV_32FC(1), 1, 0, _apertureSize, 1, 0);
cv::Sobel(local, Dy, CV_32FC(1), 0, 1, _apertureSize, 1, 0);
// parameters requried for estimations
double A = 0, B = 0, C = 0, D = 0, E = 0, F = 0;
int lx = 0, ly = 0;
for (int i = _apertureSize / 2; i <= _winSize; i++) {
float *dx_ptr = Dx.ptr< float >(i);
float *dy_ptr = Dy.ptr< float >(i);
ly = i - _winSize / 2 - _apertureSize / 2;
float *mask_ptr = mask.ptr< float >(ly + _winSize / 2);
for (int j = _apertureSize / 2; j <= _winSize; j++) {
lx = j - _winSize / 2 - _apertureSize / 2;
// cerr << lx+_winSize/2 << ":" ;
double val = mask_ptr[lx + _winSize / 2];
double dxx = dx_ptr[j] * dx_ptr[j] * val;
double dyy = dy_ptr[j] * dy_ptr[j] * val;
double dxy = dx_ptr[j] * dy_ptr[j] * val;
A = A + dxx;
B = B + dxy;
E = E + dyy;
C = C + dxx * lx + dxy * ly;
F = F + dxy * lx + dyy * ly;
}
}
// computing denominator
double det = (A * E - B * B);
if (fabs(det) > DBL_EPSILON * DBL_EPSILON) {
det = 1.0 / det;
// translating back to original corner and adding new estimates
estimate_corner.x = curr_corner.x + ((C * E) - (B * F)) * det;
estimate_corner.y = curr_corner.y + ((A * F) - (C * D)) * det;
} else {
estimate_corner.x = curr_corner.x;
estimate_corner.y = curr_corner.y;
}
dist = pointDist(estimate_corner, curr_corner);
} while (iter < _max_iters && dist > eps);
// double dist=pointDist(corners[k],estimate_corner);
if (fabs(corners[k].x - estimate_corner.x) > _winSize || fabs(corners[k].y - estimate_corner.y) > _winSize) {
estimate_corner.x = corners[k].x;
estimate_corner.y = corners[k].y;
}
corners[k].x = estimate_corner.x;
corners[k].y = estimate_corner.y;
// cerr << "EEE" << corners[k].x <<":" << corners[k].y << endl;
}
}