예제 #1
0
파일: box.cpp 프로젝트: garinh/cs
csVector3 csBox3::GetCorner (int corner) const
{
    switch (corner)
    {
    case CS_BOX_CORNER_xyz:
        return Min ();
    case CS_BOX_CORNER_xyZ:
        return csVector3 (MinX (), MinY (), MaxZ ());
    case CS_BOX_CORNER_xYz:
        return csVector3 (MinX (), MaxY (), MinZ ());
    case CS_BOX_CORNER_xYZ:
        return csVector3 (MinX (), MaxY (), MaxZ ());
    case CS_BOX_CORNER_Xyz:
        return csVector3 (MaxX (), MinY (), MinZ ());
    case CS_BOX_CORNER_XyZ:
        return csVector3 (MaxX (), MinY (), MaxZ ());
    case CS_BOX_CORNER_XYz:
        return csVector3 (MaxX (), MaxY (), MinZ ());
    case CS_BOX_CORNER_XYZ:
        return Max ();
    case CS_BOX_CENTER3:
        return GetCenter ();
    }

    return csVector3 (0, 0, 0);
}
void csBox3::ManhattanDistance (const csBox3& other, csVector3& dist) const
{
  if (other.MinX () >= MaxX ()) dist.x = other.MinX () - MaxX ();
  else if (MinX () >= other.MaxX ()) dist.x = MinX () - other.MaxX ();
  else dist.x = 0;
  if (other.MinY () >= MaxY ()) dist.y = other.MinY () - MaxY ();
  else if (MinY () >= other.MaxY ()) dist.y = MinY () - other.MaxY ();
  else dist.y = 0;
  if (other.MinZ () >= MaxZ ()) dist.z = other.MinZ () - MaxZ ();
  else if (MinZ () >= other.MaxZ ()) dist.z = MinZ () - other.MaxZ ();
  else dist.z = 0;
}
예제 #3
0
파일: box.cpp 프로젝트: garinh/cs
void csBox3::GetAxisPlane (int side, int& axis, float& where) const
{
    axis = side / 2;

    switch (side)
    {
    case CS_BOX_SIDE_x:
        where = MinX ();
        break;
    case CS_BOX_SIDE_X:
        where = MaxX ();
        break;
    case CS_BOX_SIDE_y:
        where = MinY ();
        break;
    case CS_BOX_SIDE_Y:
        where = MaxY ();
        break;
    case CS_BOX_SIDE_z:
        where = MinZ ();
        break;
    case CS_BOX_SIDE_Z:
        where = MaxZ ();
        break;
    }
}
예제 #4
0
파일: box.cpp 프로젝트: garinh/cs
csString csBox3::Description () const
{
    csString s;
    s.Format("(%g,%g,%g)-(%g,%g,%g)",
             MinX (), MinY (), MinZ (), MaxX (), MaxY (), MaxZ ());
    return s;
}
예제 #5
0
파일: classPath.cpp 프로젝트: Spo1ler/gdots
void Path::CheckChain(){
    //check if at least one enemy dot inside
    const int max_y=MaxY();
    const int min_y=MinY();
    const int max_x=MaxX();
    const int min_x=MinX();
    try{//excpeption handler to quit from loop quickly
        for(int cy=min_y; cy<=max_y; cy++){
            for(int cx=min_x; cx<=max_x; cx++){
                if(    (cx>MinXInRow(cy)   )
                    && (cx<MaxXInRow(cy)   )
                    && (cy>MinYInColumn(cx))
                    && (cy<MaxYInColumn(cx))
                    && (field->GetState(Coordinates(cx, cy)) == EXISTS)  //if dot isn't captured
                    && (field->GetColor(Coordinates(cx, cy)) == -clr)){  //if color of dot inside is enemy color
                        enemy_point_inside=true;
                        throw 1;
                }
            }
        }
    }
    catch(int i){
        return;
    }
}
예제 #6
0
파일: box.cpp 프로젝트: garinh/cs
csBox2 csBox3::GetSide (int side) const
{
    switch (side)
    {
    case CS_BOX_SIDE_x:
    case CS_BOX_SIDE_X:
        return csBox2 (MinY (), MinZ (), MaxY (), MaxZ ());
    case CS_BOX_SIDE_y:
    case CS_BOX_SIDE_Y:
        return csBox2 (MinX (), MinZ (), MaxX (), MaxZ ());
    case CS_BOX_SIDE_z:
    case CS_BOX_SIDE_Z:
        return csBox2 (MinX (), MinY (), MaxX (), MaxY ());
    }

    return csBox2 ();
}
bool csBox3::AdjacentZ (const csBox3& other) const
{
  if (ABS (other.MinZ () - MaxZ ()) < SMALL_EPSILON ||
      ABS (other.MaxZ () - MinZ ()) < SMALL_EPSILON)
  {
    if (MaxX () < other.MinX () || MinX () > other.MaxX ()) return false;
    if (MaxY () < other.MinY () || MinY () > other.MaxY ()) return false;
    return true;
  }
  return false;
}
예제 #8
0
파일: box.cpp 프로젝트: garinh/cs
bool csBox3::AdjacentZ (const csBox3 &other, float epsilon) const
{
    if (
        ABS (other.MinZ () - MaxZ ()) < epsilon ||
        ABS (other.MaxZ () - MinZ ()) < epsilon)
    {
        if (MaxX () < other.MinX () || MinX () > other.MaxX ()) return false;
        if (MaxY () < other.MinY () || MinY () > other.MaxY ()) return false;
        return true;
    }

    return false;
}
예제 #9
0
파일: box.cpp 프로젝트: garinh/cs
csVector2 csBox2::GetCorner (int corner) const
{
    switch (corner)
    {
    case CS_BOX_CORNER_xy:
        return Min ();
    case CS_BOX_CORNER_xY:
        return csVector2 (MinX (), MaxY ());
    case CS_BOX_CORNER_Xy:
        return csVector2 (MaxX (), MinY ());
    case CS_BOX_CORNER_XY:
        return Max ();
    case CS_BOX_CENTER2:
        return GetCenter ();
    }

    return csVector2 (0, 0);
}
예제 #10
0
tVector2d tSceneExtents::GeographicCenter() const
{
    return tVector2d(MinX() + MaxGeographicWidth() / 2.0,
                     MinY() + MaxGeographicHeight() / 2.0);
}
예제 #11
0
double tSceneExtents::MaxGeographicHeight() const
{
    return MaxY() - MinY();
}
예제 #12
0
tGeoRect tSceneExtents::BoundingRect() const
{
    return tGeoRect(tVector2l(static_cast<long>(floor(MinX())), static_cast<long>(floor(MinY()))), 
                    tVector2l(static_cast<long>(ceil(MaxX())), static_cast<long>(ceil(MaxY()))));
}
예제 #13
0
void TrackerCvBlobsLib::trackBlobs(const Mat &mat, const Mat &areaMask, bool history, std::vector<Area> *pareas)
{
	double min_area = *m_pmin_area;
	double max_area = *m_pmax_area;
	double max_radius_2 = *m_pmax_radius * *m_pmax_radius;
	double x, y, min_x, min_y, max_x, max_y;
	double min_depth,max_depth;
	Scalar sdepth, sstddev;
	cBlob temp;
	bool new_hand(true);
	int mat_area(mat.size().width*mat.size().height);

	// we will convert the matrix object passed from our cFilter class to an object of type IplImage for calling the CBlobResult constructor
	IplImage img;
	IplImage areaImg;

	// storage of the current blobs and the blobs from the previous frame
	Size s;	Point p;
	mat.locateROI(s,p);
	areaImg = areaMask;

	// convert our OpenCV matrix object to one of type IplImage
	img = mat;

	// cvblobslib blob extraction
	blob_result = CBlobResult(&img, NULL, 1/*img∈{0,255}->thresh unimportant*/, false);
	blob_result.Filter(blob_result, B_EXCLUDE, CBlobGetArea(), B_LESS, min_area); 
	blob_result.Filter(blob_result, B_EXCLUDE, CBlobGetArea(), B_GREATER, max_area);

	// clear the blobs from two frames ago
	blobs_previous.clear();
	
	// before we populate the blobs vector with the current frame, we need to store the live blobs in blobs_previous
	for (int i = 0; i < blobs.size(); i++)
		if (blobs[i].event != BLOB_UP)
			blobs_previous.push_back(blobs[i]);


	// populate the blobs vector with the current frame
	blobs.clear();
	for (int i = 0; i < blob_result.GetNumBlobs(); i++) {
		current_blob = blob_result.GetBlob(i);

		x     = XCenter(current_blob)/*+m_pSettingKinect->m_kinectProp.roi.x*/;
		y     = YCenter(current_blob)/*+m_pSettingKinect->m_kinectProp.roi.y*/;

//		temp.areaid = areaMask.at<uchar>((int)x+p.x,(int)y+p.y);//?!not works
		temp.areaid = (uchar) areaImg.imageData[ ((int)x+p.x) + ((int)y+p.y)*areaMask.size().width];//works
		if( temp.areaid == 0 ) continue;

		min_x = MinX(current_blob);
		min_y = MinY(current_blob);
		max_x = MaxX(current_blob);
		max_y = MaxY(current_blob);

		if( (max_x-min_x)*(max_y-min_y) > 0.9*mat_area) continue;// fix blob detection issue?!

		temp.location.x = temp.origin.x = x;
		temp.location.y = temp.origin.y = y;
		temp.min.x = min_x; temp.min.y = min_y;
		temp.max.x = max_x; temp.max.y = max_y;

		//Rect r(min_x+p.x,min_y+p.x, max_x-min_y, max_y-min_y);
		//Rect r(min_x,min_y, max_x-min_x, max_y-min_y);//width, height +1?!
		Rect r( x-3, y-3, min(7,max_x-min_x), min(7, max_y-min_y));


		//z = mean( mat(r), mat(r) )[0];/* mean is not good. The blob can include many pixel behind the frame depth*/

		/* Depth detection. The measurement method is flexible. */
		if( m_pSettingKinect->m_kinectProp.areaThresh ){
			/* Mean is ok, because all pixels of the blob are in front of the frame. */
			max_depth = mean( mat(r), mat(r) )[0]+4;/*correct blur(1) and area thresh shift (3)*/
			//meanStdDev( mat(r), sdepth, sstddev, mat(r) );
			//max_depth = sdepth[0]+3*sstddev[0];
			//minMaxLoc( mat(r), &min_depth, &max_depth, NULL, NULL, mat(r) );

		}else	if( pareas != NULL){
			/* Remove values behind the area depth and count mean of rest.
				This is problematic/choppy if to many pixels are removed.
			*/
			max_depth = max( (*pareas)[temp.areaid-1].depth-22, 
					mean( mat(r), mat(r)>(*pareas)[temp.areaid-1].depth-2 )[0] + 1);

		}else{
			/* Very few information. Use maximum of blob. (Choppy).
			 * Can be improved, if mean of i.e. 10 biggest values is used
			 * minMaxLoc require filtered/blured images.
			 * */
			//max_depth = 0;
			minMaxLoc( mat(r), &min_depth, &max_depth, NULL, NULL, mat(r) );
		}
		//printf("Compared depth of area/blob: %i %f\n",(*pareas)[temp.areaid-1].depth ,max_depth);

		/* Compare depth of hand with depth of area and throw blob away if hand to far away. */
		if(pareas != NULL && max_depth - (*pareas)[temp.areaid-1].depth < -1 ){
			//printf("Hand not reached area depth.\n");
			continue ;
		}

		temp.location.z = temp.origin.z = max_depth;

		blobs.push_back(temp);
	}

	// initialize previous blobs to untracked
	float d1,d2;
	for (int i = 0; i < blobs_previous.size(); i++) blobs_previous[i].tracked = false;

	// main tracking loop -- O(n^2) -- simply looks for a blob in the previous frame within a specified radius
	for (int i = 0; i < blobs.size(); i++) {
		cBlob &blobi = blobs[i];
		new_hand = true;
		for (int j = 0; j < blobs_previous.size(); j++) {
			if (blobs_previous[j].tracked) continue;

			d1=blobs[i].location.x - blobs_previous[j].location.x;
			d2=blobs[i].location.y - blobs_previous[j].location.y;
			if (blobs[i].areaid == blobs_previous[j].areaid 
					&& (d1*d1 + d2*d2) < max_radius_2) {
				blobs_previous[j].tracked = true;
				blobs[i].event = BLOB_MOVE;
				blobs[i].origin.x = history ? blobs_previous[j].origin.x : blobs_previous[j].location.x;
				blobs[i].origin.y = history ? blobs_previous[j].origin.y : blobs_previous[j].location.y;
				blobs[i].origin.z = history ? blobs_previous[j].origin.z : blobs_previous[j].location.z;

				blobs[i].handid = blobs_previous[j].handid;
				blobs[i].cursor = blobs_previous[j].cursor;
				blobs[i].cursor25D = blobs_previous[j].cursor25D;
				new_hand = false;
				break;
			}
		}
		/* assing free handid if new blob */
		if( new_hand){

			//search next free id.
			int next_handid = (last_handid+1) % MAXHANDS;//or = 0;
			while( handids[next_handid]==true && next_handid!=last_handid ){
					next_handid = (next_handid+1) % MAXHANDS;
			} //if array full -> next_handid = last_handid

			blobs[i].event = BLOB_DOWN;
			blobs[i].handid = next_handid;
			blobs[i].cursor = NULL;
			blobs[i].cursor25D = NULL;

			handids[next_handid] = true;
			last_handid = next_handid;
		}
	}

	// add any blobs from the previous frame that weren't tracked as having been removed
	for (int i = 0; i < blobs_previous.size(); i++) {
		if (!blobs_previous[i].tracked) {
			//free handid
			handids[blobs_previous[i].handid] = false;
			blobs_previous[i].event = BLOB_UP;
			blobs.push_back(blobs_previous[i]);
		}
	}
/*
	for (int i = 1; i < blob_result.GetNumBlobs(); i++) {
				current_blob = blob_result.GetBlob(i);
				printf("Blobcoordsd %f, %f\n", XCenter(current_blob), YCenter(current_blob) );
	}
*/
	int counter = 0;
	cBlob tb;
	for (int i = 0; i < blobs.size(); i++) {
			if( blobs[i].event != BLOB_UP ){
				counter++;
				tb = blobs[i];
				//printf("Blobcoordsd %f, %f\n", blobs[i].location.x, blobs[i].location.y );
				//printf("Blob areaid: %i, handid: %i, (%f,%f)\n", blobs[i].areaid, blobs[i].handid, blobs[i].location.x, blobs[i].location.y );
				if(! *m_pnotDrawBlob ){
					cvLine(&img,
							Point((int)tb.origin.x,(int)tb.origin.y),
							Point((int)tb.location.x,(int)tb.location.y),Scalar(244),2);
					cvRectangle(&img,
							Point((int)tb.min.x,(int)tb.min.y),
							Point((int)tb.max.x,(int)tb.max.y),Scalar(255),2);
				}
			}
	}
//	printf("Active blobs: %i %i %i\n",counter, blobs.size(), blob_result.GetNumBlobs());
/*	for(int i=0; i<MAXHANDS; i++){
		printf("%i,", (handids[i]==true)?1:0);
	}
	printf("\n");*/
}
예제 #14
0
	AndRectRegion(), OrRectRegion(), ClearRectRegion()

    INTERNALS

    HISTORY
	27-11-96    digulla automatically created from
			    graphics_lib.fd and clib/graphics_protos.h
	19-01-97    mreckt  intital version

*****************************************************************************/
{
    AROS_LIBFUNC_INIT

    struct Region R;
    struct RegionRectangle rr;

    InitRegion(&R);

    R.bounds = *Rect;
    R.RegionRectangle = &rr;

    rr.Next = NULL;
    MinX(&rr) = MinY(&rr) = 0;
    MaxX(&rr) = Rect->MaxX - Rect->MinX;
    MaxY(&rr) = Rect->MaxY - Rect->MinY;

    return XorRegionRegion(&R, Reg);

    AROS_LIBFUNC_EXIT
} /* XorRectRegion */
예제 #15
0
//****************************************************************************
//
// * Get the value at x, y
//============================================================================
SJCVector2d SJCVectorField2d::
Value(const double x_pos, const double y_pos)
//============================================================================
{
  // Check whether the position is out of bound
  if(x_pos < MinX() || x_pos > MaxX() || 
     y_pos < MinY() || y_pos > MaxY()){
    SJCWarning("X or Y out of bound in getting value");
    return SJCVector2d(0.f, 0.f);
  }
  

  // Compute the index position
  double x = (x_pos - m_dHalfDX) / m_dDX;
  double y = (y_pos - m_dHalfDY) / m_dDY;
 
  uint	   index_xl, index_xr;    // the left and right index in x
  uint	   index_yb, index_yt;    // The top and bottom index in y
  double   partial_x,  partial_y; // The partial in x and y

  // Here should have judgement when x_pos and y_pos are close to index 
  // position
  switch ( m_VBoundary[0] )   { // Check and set up the correct value for x,y 
                                // according the boundary conditions
    case BOUNDARY_NOWRAP: 
    case BOUNDARY_NOWRAP_FREE:
      if ( x == m_uNX - 1.f) {
	index_xr  = (uint)m_uNX - 1;
	index_xl  = index_xr - 1;
	partial_x = 1.0f;
      }
      else {
	index_xl  = (uint)floor(x);
	index_xr  = index_xl + 1;
	partial_x = x - (double)index_xl;
      }
      break;

    case BOUNDARY_WRAP: 
      double	xp = fmod(x, (double)m_uNX);
      if ( xp < 0.0 )
	xp = xp + (int)m_uNX;
      
      index_xl  = (uint)floor(xp);
      index_xr  = (index_xl + 1) % m_uNX;
      partial_x = xp - (double)index_xl;
      break;
  } // end of switch

  switch ( m_VBoundary[1] )   {
    case BOUNDARY_NOWRAP:
    case BOUNDARY_NOWRAP_FREE:
      if ( y == m_uNY - 1.f ) {
	index_yt  = (uint)m_uNY - 1;
	index_yb  = index_yt - 1;
	partial_y = 1.0f;
      }
      else {
	index_yb  = (uint)floor(y);
	index_yt  = index_yb + 1;
 	partial_y = y - (double)index_yb;
      }
      break;

    case BOUNDARY_WRAP: 
      double 	yp = fmod(y, (double)m_uNY);
      if ( yp < 0.0 )
	yp = yp + (int)m_uNY;
      
      index_yb  = (uint)floor(yp);
      index_yt  = (index_yb + 1) % m_uNY;
      partial_y = yp - (double)index_yb;
      break;
  }

  SJCVector2d vBottomLeft  = m_VData[Index(index_xl, index_yb)];
  SJCVector2d vTopLeft     = m_VData[Index(index_xl, index_yt)];
  SJCVector2d vBottomRight = m_VData[Index(index_xr, index_yb)];
  SJCVector2d vTopRight    = m_VData[Index(index_xr, index_yt)];

  return (1.f-partial_x)*(1.f-partial_y)   * vBottomLeft + 
         partial_y      *(1.f - partial_x) * vTopLeft + 
         partial_x      *(1.f - partial_y) * vBottomRight + 
         partial_x      *partial_y         * vTopRight;
}