bool JunctionArea::calculateReconstruction()
{
unsigned int i;
if (m_enteringSequences.size() == 0)
return 0;
//Apply preliminary tests for this Junction Area
// a) Check if endpoints got absorbed by the expansion process
for (i = 0; i < m_jointsAbsorbed.size(); ++i)
if (currJSGraph->getNode(m_jointsAbsorbed[i]).degree() == 1)
return 0;
// b) Check if the contours shape resembles that of a crossing
sort(m_enteringSequences.begin(), m_enteringSequences.end(),
EntSequenceLess());
if (!checkShape())
return 0;
// c) Build the new junction Point plane position
if (!solveJunctionPosition())
return 0;
// d) Build joint optimal heights (each for entering sequence...)
if (!makeHeights())
return 0;
return 1;
}
bool ShapeCollisionImage::collide(SimCollisionImage* image, CollisionSurfaceList *list )
{
AssertFatal(collisionDetail!=-1,
"ShapeCollisionImage::collide: collisionDetail not set or set improperly.");
AssertFatal(shapeInst,
"ShapeCollisionImage::collide: shape not set or set improperly.");
TMat3F mat;
switch (image->getType()) {
case Sphere: {
buildImageTransform(image,list,&mat);
SimCollisionSphereImage* si = static_cast<SimCollisionSphereImage*>(image);
return shapeInst->collideSphere
(collisionDetail,si->center,si->radius,&mat,list,
collisionLevel==CollideFaces);
}
case Box: {
buildImageTransform(image,list,&mat);
SimCollisionBoxImage* bi = static_cast<SimCollisionBoxImage*>(image);
return checkBox(bi,&mat,list);
}
case Tube: {
buildImageTransform(image,list,&mat);
SimCollisionTubeImage* ti = static_cast<SimCollisionTubeImage*>(image);
return shapeInst->collideTube
(collisionDetail,ti->start,ti->end,ti->radius,&mat,list,
collisionLevel==CollideFaces);
}
case Line: {
// Collides line with TS3 shape
// Lines always collide with the highest detail level.
buildImageTransform(image,list,&mat);
SimCollisionLineImage* li = static_cast<SimCollisionLineImage*>(image);
return shapeInst->collideLine(0,li->start,li->end,&mat,list,
collisionLevel==CollideFaces);
}
//
case Terrain: {
SimCollisionTerrImage* ti = static_cast<SimCollisionTerrImage*>(image);
return checkTerrain(ti,list);
}
case Interior: {
SimCollisionItrImage* ii = static_cast<SimCollisionItrImage*>(image);
return checkInterior(ii,list);
}
case ShapeCollisionImageType: {
ShapeCollisionImage* si = static_cast<ShapeCollisionImage*>(image);
return checkShape(si,list);
}
default:
AssertFatal(0,"ShapeCollisionImage:collide: Unrecognized type");
break;
}
return false;
}
void ImageAnalyzer::findObjects(cv::Mat& img)
{
/* Point 2D */
cv::Point pt1, pt2;
/* Maps needed for BlobAnalysis */
map < char, map< int,Blob* > >:: iterator BlobsItr1;
map< int,Blob* > :: iterator BlobsItr2;
/* initialise classes to store data regarding the found blobs */
BlobInfo ghost_blob(GHOST_CLASS);
/* Blob parameters, PixMap object initialisation */
PixelMap pixmap((unsigned char*)img.data, img.cols, img.rows, cc, 3);
/* Start blob growing algorithm: parameters from the 2nd to the 5th
* identify the region of the image in which blobs are to be searched for
* (2nd to 5th params are set to -1 ==> search blobs over the whole image)
*/
pixmap.BlobGrowing(1,-1,-1,-1,-1);
for(BlobsItr1=pixmap.GetBlobs()->begin();BlobsItr1!=pixmap.GetBlobs()->end();BlobsItr1++)
{
for(BlobsItr2 = BlobsItr1->second.begin();BlobsItr2!=BlobsItr1->second.end();BlobsItr2++)
{
if(BlobsItr2->second->GetValid() && BlobsItr2->second->GetNumPix()>MIN_BLOB_SIZE)
{
/* load blob coordinates */
/* top left point */
pt1.x = BlobsItr2->second->GetMinX();
pt1.y = BlobsItr2->second->GetMaxY();
/* bottom right point */
pt2.x = BlobsItr2->second->GetMaxX();
pt2.y = BlobsItr2->second->GetMinY();
/* compute width and height to perform some check... */
int blob_width = pt2.x - pt1.x;
int blob_heigth = pt1.y - pt2.y;
/* is the blob shape similar to the expected one? */
/* save the biggest found blob for each colour class */
if(BlobsItr1->first == GHOST_CLASS &&
BlobsItr2->second->GetNumPix() > ghost_blob.getNumPix() &&
checkShape(blob_width, blob_heigth) )
{
ghost_blob.save(BlobsItr2->second->GetNumPix(), pt1, pt2);
}
}
}
}
/* add results to buffer */
ghost_buffer.addIfPresent(ghost_blob);
}
void LogicHEfunshop::op_1004(int32 *args) {
double data[8], at, sq;
int32 x, y;
int i=0;
for (i = 0; i <= 6; i += 2) {
data[i] = getFromArray(args[0], 0, 519 + i);
data[i + 1] = getFromArray(args[0], 0, 519 + i + 1);
}
int s = checkShape((int32)data[0], (int32)data[1], (int32)data[4], (int32)data[5],
(int32)data[2], (int32)data[3], (int32)data[6], (int32)data[7], &x, &y);
if (s != 1) {
error("LogicHEfunshop::op_1004: Your shape has defied the laws of physics");
return;
}
for (i = 0; i <= 6; i += 2) {
data[i] -= (double)x;
data[i + 1] -= (double)y;
}
double a1 = (double)args[1] * DEG2RAD;
for (i = 0; i <= 6; i += 2) {
at = atan2(data[i + 1], data[i]);
sq = sqrt(data[i + 1] * data[i + 1] + data[i] * data[i]);
if (at <= 0)
at += 2 * M_PI;
data[i] = cos(at + a1) * sq;
data[i + 1] = sin(at + a1) * sq;
}
double minx = data[0];
double miny = data[1];
for (i = 0; i <= 6; i += 2) {
if (data[i] < minx)
minx = data[i];
if (data[i + 1] < miny)
miny = data[i + 1];
}
for (i = 0; i <= 6; i += 2) {
data[i] -= minx;
data[i + 1] -= miny;
putInArray(args[0], 0, 519 + i, scumm_round(data[i]));
putInArray(args[0], 0, 519 + i + 1, scumm_round(data[i + 1]));
}
}
bool PlayerCollisionImage::collide(SimCollisionImage* image, CollisionSurfaceList *list )
{
AssertFatal(collisionDetail!=-1,
"PlayerCollisionImage::collide: collisionDetail not set or set improperly.");
AssertFatal(shapeInst,
"PlayerCollisionImage::collide: shape not set or set improperly.");
// Test collision of image argument against this image.
// Collision surfaces are returned in this image space.
// Build the transform which goes from image space to the
// space in which the testing will take place.
TMat3F mat;
list->stepVector.set(0,0,-1);
// Do the tests...
switch (image->getType()) {
case Sphere: {
buildImageTransform(image,list,&mat);
SimCollisionSphereImage* si = static_cast<SimCollisionSphereImage*>(image);
return shapeInst->collideSphere
(collisionDetail,si->center,si->radius,&mat,list,
collisionLevel==CollideFaces);
}
case Box: {
buildImageTransform(image,list,&mat);
SimCollisionBoxImage* bi = static_cast<SimCollisionBoxImage*>(image);
return checkBox(bi,&mat,list);
}
case Tube: {
buildImageTransform(image,list,&mat);
SimCollisionTubeImage* ti = static_cast<SimCollisionTubeImage*>(image);
return shapeInst->collideTube
(collisionDetail,ti->start,ti->end,ti->radius,&mat,list,
collisionLevel==CollideFaces);
}
case Line: {
Point3F a,b;
RealF hit;
SimCollisionLineImage *line = static_cast<SimCollisionLineImage *>(image);
Parent::buildImageTransform(image, &mat);
m_mul(line->start, mat, &a);
m_mul(line->end, mat, &b);
if(m_lineAABox(a, b, crouchBox.fMin, crouchBox.fMax, hit))
{
CollisionSurface surface;
surface.time = hit;
surface.position.x = line->start.x + (hit * (line->end.x - line->start.x));
surface.position.y = line->start.y + (hit * (line->end.y - line->start.y));
surface.position.z = line->start.z + (hit * (line->end.z - line->start.z));
surface.distance = m_distf(surface.position, line->start);
surface.normal.set(0, 0, 1); // incomplete and wrong
surface.material = surface.surface = 0;
list->tWorld.identity();
list->push_back(surface);
return (true);
}
return (false);
#if 0
// Collides line with bounding box (axis-aligned) -- easier to hit
// than line/TS3, more accurate than line/Sphere
float rTime = 0.0f;
Point3F objStart, objEnd;
Parent::buildImageTransform(image, &mat);
SimCollisionLineImage *line = static_cast<SimCollisionLineImage *>(image);
m_mul(line->start, mat, &objStart);
m_mul(line->end, mat, &objEnd);
return (m_lineAABox(objStart, objEnd,
bbox.fMin, bbox.fMax, rTime) && rTime > 0.0f);
#endif
#if 0
// Collides line with sphere -- temporary "fix" to make it a little
//easier to hit others
SimCollisionSphereImage sphere;
sphere.center = this->sphere.center;
sphere.radius = this->sphere.radius;
sphere.transform = transform;
SimCollisionLineImage *line =
static_cast<SimCollisionLineImage *>(image);
return (line->collide(&sphere, list));
#endif
#if 0
// Collides line with TS3 shape -- very difficult to hit
buildImageTransform(image,list,&mat);
SimCollisionLineImage* li = static_cast<SimCollisionLineImage*>(image);
return shapeInst->collideLine
(collisionDetail,li->start,li->end,&mat,list,
collisionLevel==CollideFaces);
#endif
}
//
case Terrain: {
SimCollisionTerrImage* ti = static_cast<SimCollisionTerrImage*>(image);
return checkTerrain(ti,list);
}
case Interior: {
SimCollisionItrImage* ii = static_cast<SimCollisionItrImage*>(image);
return checkInterior(ii,list);
}
case ShapeCollisionImageType: {
ShapeCollisionImage* si = static_cast<ShapeCollisionImage*>(image);
return checkShape(si,list);
}
case PlayerCollisionImageType: {
PlayerCollisionImage* pi = static_cast<PlayerCollisionImage*>(image);
return checkPlayer(pi,list);
}
default:
AssertFatal(0,"PlayerCollisionImage:collide: Unrecognized type");
break;
}
return false;
}
