RS_Vector RS_Image::getNearestDist(double distance,
const RS_Vector& coord,
double* dist) const{
RS_VectorSolutions const& corners = getCorners();
RS_VectorSolutions points;
for (size_t i = 0; i < corners.size(); ++i){
size_t const j = (i+1)%corners.size();
RS_Line const l{corners.get(i), corners.get(j)};
RS_Vector const& vp = l.getNearestDist(distance, coord, dist);
points.push_back(vp);
}
return points.getClosest(coord, dist);
}
GMPlaneIntersectionType GMBoundingBox::intersects(const GMPlane& plane) const
{
GMVector3D corners[8];
getCorners(corners);
double lastdistance = plane.normalVec.dot(corners[0]) + plane.distance;
for (int i = 1; i < 8; i++) {
double distance = plane.normalVec.dot(corners[i]) + plane.distance;
if ((distance <= 0.0 && lastdistance > 0.0) || (distance >= 0.0 && lastdistance < 0.0)) {
return GMPlaneIntersectionTypeIntersecting;
}
lastdistance = distance;
}
return (lastdistance > 0.0f)? GMPlaneIntersectionTypeFront: GMPlaneIntersectionTypeBack;
}
void CoverMap::fillTemp(UnitType toBuild, TilePosition buildSpot)
{
Corners c = getCorners(toBuild, buildSpot);
for (int x = c.x1; x <= c.x2; x++)
{
for (int y = c.y1; y <= c.y2; y++)
{
if (x >= 0 && x < w && y >= 0 && y < h)
{
if (cover_map[x][y] == BUILDABLE)
{
cover_map[x][y] = TEMPBLOCKED;
}
}
}
}
}
bool DoorObject::operator< (DoorObject& D)
{
// compare the corners
vector<Coord> c1 = getCorners();
vector<Coord> c2 = D.getCorners();
// must have same number of corners
if(c1.size() != c2.size()) return false;
// compare every corner in the sets
vector<Coord>::iterator i1 = c1.begin(), i2 = c2.begin();
while(i1 != c1.end() && i2 != c2.end())
{
if(*i1 != *i2) return false;
i1++; i2++;
}
return true;
}
Vec3 Box::pointForceIntersect(PointForce pf) {
DEBUG_LOG("Searching for intersection");
Vec3 *tmpCorners[4];
getCorners(&tmpCorners[0],&tmpCorners[1],&tmpCorners[2],&tmpCorners[3]);
Vec3 *intersection;
if(Vec3::findIntersection(pf.getPosition(),pf.getPrevPos(), *tmpCorners[0], *tmpCorners[1], &intersection)) {
DEBUG_LOG("returning intersection at " << *intersection);
delete tmpCorners[0];
delete tmpCorners[1];
delete tmpCorners[2];
delete tmpCorners[3];
return Vec3(*intersection);
}
if(Vec3::findIntersection(pf.getPosition(),pf.getPrevPos(), *tmpCorners[1], *tmpCorners[2], &intersection)) {
DEBUG_LOG("returning intersection at " << *intersection);
delete tmpCorners[0];
delete tmpCorners[1];
delete tmpCorners[2];
delete tmpCorners[3];
return Vec3(*intersection);
}
if(Vec3::findIntersection(pf.getPosition(),pf.getPrevPos(), *tmpCorners[2], *tmpCorners[3], &intersection)) {
DEBUG_LOG("returning intersection at " << *intersection);
delete tmpCorners[0];
delete tmpCorners[1];
delete tmpCorners[2];
delete tmpCorners[3];
return Vec3(*intersection);
}
if(Vec3::findIntersection(pf.getPosition(),pf.getPrevPos(), *tmpCorners[3], *tmpCorners[0], &intersection)) {
DEBUG_LOG("returning intersection at " << *intersection);
delete tmpCorners[0];
delete tmpCorners[1];
delete tmpCorners[2];
delete tmpCorners[3];
return Vec3(*intersection);
}
DEBUG_LOG("No intersection found")
return Vec3();
}
RS_Vector RS_Image::getNearestCenter(const RS_Vector& coord,
double* dist) {
RS_VectorSolutions points;
RS_VectorSolutions corners = getCorners();
//bug#485, there's no clear reason to ignore snapping to center within an image
// if(containsPoint(coord)){
// //if coord is within image
// if(dist!=NULL) *dist=0.;
// return coord;
// }
points.push_back((corners.get(0) + corners.get(1))/2.0);
points.push_back((corners.get(1) + corners.get(2))/2.0);
points.push_back((corners.get(2) + corners.get(3))/2.0);
points.push_back((corners.get(3) + corners.get(0))/2.0);
points.push_back((corners.get(0) + corners.get(2))/2.0);
return points.getClosest(coord, dist);
}
RS_Vector RS_Image::getNearestCenter(const RS_Vector& coord,
double* dist) const{
RS_VectorSolutions const& corners{getCorners()};
//bug#485, there's no clear reason to ignore snapping to center within an image
// if(containsPoint(coord)){
// //if coord is within image
// if(dist) *dist=0.;
// return coord;
// }
RS_VectorSolutions points;
for (size_t i=0; i < corners.size(); ++i) {
size_t const j = (i+1)%corners.size();
points.push_back((corners.get(i) + corners.get(j))*0.5);
}
points.push_back((corners.get(0) + corners.get(2))*0.5);
return points.getClosest(coord, dist);
}
RS_Vector RS_Image::getNearestDist(double distance,
const RS_Vector& coord,
double* dist) {
RS_VectorSolutions corners = getCorners();
RS_VectorSolutions points(4);
RS_Line l[] =
{
RS_Line(NULL, RS_LineData(corners.get(0), corners.get(1))),
RS_Line(NULL, RS_LineData(corners.get(1), corners.get(2))),
RS_Line(NULL, RS_LineData(corners.get(2), corners.get(3))),
RS_Line(NULL, RS_LineData(corners.get(3), corners.get(0)))
};
for (int i=0; i<4; ++i) {
points.set(i, l[i].getNearestDist(distance, coord, dist));
}
return points.getClosest(coord, dist);
}
double RS_Image::getDistanceToPoint(const RS_Vector& coord,
RS_Entity** entity,
RS2::ResolveLevel /*level*/,
double /*solidDist*/) const{
if (entity!=NULL) {
*entity = const_cast<RS_Image*>(this);
}
RS_VectorSolutions corners = getCorners();
//allow selecting image by clicking within images, bug#3464626
if(containsPoint(coord)){
//if coord is on image
RS_SETTINGS->beginGroup("/Appearance");
bool draftMode = (bool)RS_SETTINGS->readNumEntry("/DraftMode", 0);
RS_SETTINGS->endGroup();
if(!draftMode) return double(0.);
}
//continue to allow selecting by image edges
double dist;
double minDist = RS_MAXDOUBLE;
RS_Line l[] =
{
RS_Line(NULL, RS_LineData(corners.get(0), corners.get(1))),
RS_Line(NULL, RS_LineData(corners.get(1), corners.get(2))),
RS_Line(NULL, RS_LineData(corners.get(2), corners.get(3))),
RS_Line(NULL, RS_LineData(corners.get(3), corners.get(0)))
};
for (int i=0; i<4; ++i) {
dist = l[i].getDistanceToPoint(coord, NULL);
if (dist<minDist) {
minDist = dist;
}
}
return minDist;
}
void MeshComponent::constructTransformedAABB()
{
m_transformedAABB.reset();
auto modelSpaceAABB = m_meshData->getAABB();
if (!modelSpaceAABB || !modelSpaceAABB->isValid())
return;
// Get the corners of original AABB (model-space).
std::vector<glm::vec3> aabbCorners(8);
modelSpaceAABB->getCorners(aabbCorners);
// Create new AABB from the corners of the original also applying world transformation.
auto tr = getHolder()->transform()->getTransformation();
for (auto &p : aabbCorners)
{
auto trp = tr * glm::vec4(p, 1.0f);
m_transformedAABB.updateBounds(glm::vec3(trp));
}
m_transformedAabbDirty = false;
}
void BoundingBox::transform(const Matrix& matrix)
{
// Calculate the corners.
Vector3 corners[8];
getCorners(corners);
// Transform the corners, recalculating the min and max points along the way.
matrix.transformPoint(&corners[0]);
Vector3 newMin = corners[0];
Vector3 newMax = corners[0];
for (int i = 1; i < 8; i++)
{
matrix.transformPoint(&corners[i]);
updateMinMax(&corners[i], &newMin, &newMax);
}
this->min.x = newMin.x;
this->min.y = newMin.y;
this->min.z = newMin.z;
this->max.x = newMax.x;
this->max.y = newMax.y;
this->max.z = newMax.z;
}
void CoverMap::clearTemp(UnitType toBuild, TilePosition buildSpot)
{
if (buildSpot.x() == -1)
{
return;
}
Corners c = getCorners(toBuild, buildSpot);
for (int x = c.x1; x <= c.x2; x++)
{
for (int y = c.y1; y <= c.y2; y++)
{
if (x >= 0 && x < w && y >= 0 && y < h)
{
if (cover_map[x][y] == TEMPBLOCKED)
{
cover_map[x][y] = BUILDABLE;
}
}
}
}
}
void BoundingBox::transform(const kmMat4& matrix)
{
// Calculate the corners.
kmVec3 corners[8];
getCorners(corners);
// Transform the corners, recalculating the min and max points along the way.
//matrix.transformPoint(&corners[0]);
kmMat3Transform(&corners[0], &matrix, corners[0].x, corners[0].y, corners[0].z, 1.0f);
kmVec3 newMin = corners[0];
kmVec3 newMax = corners[0];
for (int i = 1; i < 8; i++)
{
//matrix.transformPoint(&corners[i]);
kmMat3Transform(&corners[i], &matrix, corners[i].x, corners[i].y, corners[i].z, 1.0f);
updateMinMax(&corners[i], &newMin, &newMax);
}
this->min.x = newMin.x;
this->min.y = newMin.y;
this->min.z = newMin.z;
this->max.x = newMax.x;
this->max.y = newMax.y;
this->max.z = newMax.z;
}
RS_Vector RS_Image::getNearestPointOnEntity(const RS_Vector& coord,
bool onEntity, double* dist, RS_Entity** entity) const{
if (entity) {
*entity = const_cast<RS_Image*>(this);
}
RS_VectorSolutions const& corners =getCorners();
//allow selecting image by clicking within images, bug#3464626
if(containsPoint(coord)){
//if coord is within image
if(dist) *dist=0.;
return coord;
}
RS_VectorSolutions points;
for (size_t i=0; i < corners.size(); ++i){
size_t const j = (i+1)%corners.size();
RS_Line const l{corners.at(i), corners.at(j)};
RS_Vector const vp = l.getNearestPointOnEntity(coord, onEntity);
points.push_back(vp);
}
return points.getClosest(coord, dist);
}
RS_Vector RS_Image::getNearestEndpoint(const RS_Vector& coord,
double* dist) const {
RS_VectorSolutions corners =getCorners();
return corners.getClosest(coord, dist);
}
CoverMap::CoverMap()
{
w = Broodwar->mapWidth();
h = Broodwar->mapHeight();
range = 30;
Unit* worker = findWorker();
cover_map = new int*[w];
for(int i = 0 ; i < w ; i++)
{
cover_map[i] = new int[h];
//Fill from static map and Region connectability
for (int j = 0; j < h; j++)
{
int ok = BUILDABLE;
if (!Broodwar->isBuildable(i, j))
{
ok = BLOCKED;
}
cover_map[i][j] = ok;
}
}
//Fill from current agents
vector<BaseAgent*> agents = AgentManager::getInstance()->getAgents();
for (int i = 0; i < (int)agents.size(); i++)
{
BaseAgent* agent = agents.at(i);
if (agent->isBuilding())
{
Corners c = getCorners(agent->getUnit());
fill(c);
}
}
//Fill from minerals
for(set<Unit*>::iterator m = Broodwar->getMinerals().begin(); m != Broodwar->getMinerals().end(); m++)
{
Corners c;
c.x1 = (*m)->getTilePosition().x() - 1;
c.y1 = (*m)->getTilePosition().y() - 1;
c.x2 = (*m)->getTilePosition().x() + 2;
c.y2 = (*m)->getTilePosition().y() + 1;
fill(c);
cover_map[c.x1+2][c.y1+2] = MINERAL;
}
//Fill from gas
for(set<Unit*>::iterator m = Broodwar->getGeysers().begin(); m != Broodwar->getGeysers().end(); m++)
{
Corners c;
c.x1 = (*m)->getTilePosition().x() - 2;
c.y1 = (*m)->getTilePosition().y() - 2;
c.x2 = (*m)->getTilePosition().x() + 5;
c.y2 = (*m)->getTilePosition().y() + 3;
fill(c);
cover_map[c.x1+2][c.y1+2] = GAS;
}
//Fill from narrow chokepoints
if (analyzed)
{
for(set<Region*>::const_iterator i=getRegions().begin();i!=getRegions().end();i++)
{
for(set<Chokepoint*>::const_iterator c=(*i)->getChokepoints().begin();c!=(*i)->getChokepoints().end();c++)
{
if ((*c)->getWidth() <= 4 * 32)
{
TilePosition center = TilePosition((*c)->getCenter());
Corners c;
c.x1 = center.x() - 1;
c.x2 = center.x() + 1;
c.y1 = center.y() - 1;
c.y2 = center.y() + 1;
fill(c);
}
}
}
}
mapData = MapDataReader();
mapData.readMap();
}
Corners CoverMap::getCorners(Unit* unit)
{
return getCorners(unit->getType(), unit->getTilePosition());
}
void HarrisDetector::getCorners( std::vector<cv::Point> &points, double qualityLevel){
cv::Mat cornerMap = getCornerMap(qualityLevel);
getCorners(points, cornerMap);
}
bool CoverMap::canBuild(UnitType toBuild, TilePosition buildSpot)
{
Corners c = getCorners(toBuild, buildSpot);
//Step 1: Check covermap.
for (int x = c.x1; x <= c.x2; x++)
{
for (int y = c.y1; y <= c.y2; y++)
{
if (x >= 0 && x < w && y >= 0 && y < h)
{
if (cover_map[x][y] != BUILDABLE)
{
//Cant build here.
return false;
}
}
else
{
//Out of bounds
return false;
}
}
}
//Step 2: Check if path is available
if (!ExplorationManager::canReach(Broodwar->self()->getStartLocation(), buildSpot))
{
return false;
}
//Step 3: Check canBuild
Unit* worker = findWorker();
if (worker == NULL)
{
//No worker available
return false;
}
//Step 4: Check any units on tile
if (AgentManager::getInstance()->unitsInArea(buildSpot, toBuild.tileWidth(), toBuild.tileHeight(), worker->getID()))
{
return false;
}
//Step 5: If Protoss, check PSI coverage
if (BuildPlanner::isProtoss())
{
if (toBuild.requiresPsi())
{
if (!Broodwar->hasPower(buildSpot, toBuild.tileWidth(), toBuild.tileHeight()))
{
return false;
}
}
}
//Step 6: If Zerg, check creep
if (BuildPlanner::isZerg())
{
if (UnitAgent::isOfType(toBuild, UnitTypes::Zerg_Hatchery))
{
//Do not build if we have creep (to spread creep out)
if (Broodwar->hasCreep(buildSpot))
{
return false;
}
}
else if (toBuild.requiresCreep())
{
if (!Broodwar->hasCreep(buildSpot))
{
return false;
}
}
}
//Step 7: If detector, check if spot is already covered by a detector
/*if (toBuild.isDetector())
{
if (!suitableForDetector(buildSpot))
{
return false;
}
}*/
//All passed. It is possible to build here.
return true;
}
