コード例 #1
0
ファイル: Camera2.cpp プロジェクト: Melorr/SP2
bool BoundaryCheck(const Vector3& CameraPosition) {
    Vector3 MaxPoint(240, 240, 240);
    Vector3 MinPoint(-240, -240, -240);
    if (CameraPosition.x > MinPoint.x && CameraPosition.x < MaxPoint.x &&
            CameraPosition.y > MinPoint.y && CameraPosition.y < MaxPoint.y &&
            CameraPosition.z > MinPoint.z && CameraPosition.z < MaxPoint.z)
    {
        return true;
    }
    else {
        return false;
    }
}
コード例 #2
0
ファイル: sampleco.c プロジェクト: pcraster/pcraster
/* Calculates one pixel from output map, given the input maps.
 * Puts all values of input pixels in a list and determines the value of
 * the output pixel according to these values and the overlapping areas.
 * Returns 0 if no error occurs, 1 otherwise.
 */
static int CalcPixel(
	MAP *out,		/* write-only output map */
 	MAP **in,		/* read-only list input maps */
 	size_t nrCoverCells,	/* min. nr. non-MV cells for non-MV */
 	size_t nrMaps,		/* nr. of input maps */
 	double rOut,		/* row number pixel */
 	double cOut,		/* column number pixel */
 	BOOL aligned,		/* maps are aligned */
 	REAL8 angle)		/* angle of output map */
{		
	PTYPE 	tlX, tlY, trX, trY, brX, brY, blX, blY;
	double 	r, c;
	DATA 	*list = NULL;  	/* areas and values of input cells */
   	size_t 	i, nrList = 0;	/* number of items in list */
	POINT2D 	*outputCell;	/* polygon of output cell */
   	size_t 	nr = 4;		/* nr of points of cell */
   	CSF_VS	vs;		/* value scale of first input map */

	if(nrCoverCells > 0 && nrMaps > 1)
		raster = InitRaster(raster); /* initialize the raster */

   	/* Determine the four corners of output pixel */
   	RrowCol2Coords(out, rOut, cOut, &tlX, &tlY); /* top left */
   	RrowCol2Coords(out, rOut, cOut + 1, &trX, &trY); /* top right */
   	RrowCol2Coords(out, rOut + 1, cOut, &blX, &blY); /* bottom left */
   	RrowCol2Coords(out, rOut + 1, cOut + 1, &brX, &brY); /* bottom right */
	outputCell = PutInPol(tlX, tlY, trX, trY, brX, brY, blX, blY);
	if(outputCell == NULL)
		return 1;

	POSTCOND(outputCell[0].x == outputCell[nr].x);
	POSTCOND(outputCell[0].y == outputCell[nr].y);

	/* Get pixel on every input map */
	for(i = 0; i < nrMaps; i++)
	{
		MAP 	*X = in[i];	/* input map number i */
		PTYPE 	tlC, tlR, trC, trR, brC, brR, blC, blR;
		PTYPE 	tlX2, tlY2, trX2, trY2, brX2, brY2, blX2, blY2;
   		double 	leftB, belowB, rightB, upperB;	/* boundaries */

		/* Corners: (tlX, tlY), (trX, trY), (blX, blY) and
		 * (brX, brY). Translate for input map.
		 */
   		Rcoords2RowCol(X, tlX, tlY, &tlC, &tlR); /* top left */
   		Rcoords2RowCol(X, trX, trY, &trC, &trR); /* top right */
   		Rcoords2RowCol(X, blX, blY, &blC, &blR); /* bottom left */
   		Rcoords2RowCol(X, brX, brY, &brC, &brR); /* bottom right */

   		/* Boundaries in the input map */
   		rightB = ceil(MaxPoint(tlR, trR, blR, brR));	
   		belowB = ceil(MaxPoint(tlC, trC, blC, brC));	
   		leftB = floor(MinPoint(tlR, trR, blR, brR));	
   		upperB = floor(MinPoint(tlC, trC, blC, brC));	
   		
		PRECOND(upperB <= belowB);
		PRECOND(leftB <= rightB);

		/* Check all cells between the boundaries */
		for(r = upperB; r < belowB; r++)
		{
			REAL8 *currRow;
			if(0 <= r && r <= RgetNrRows(X))
		 	 currRow = (REAL8 *)CacheGetRow(in, i,  r);

			for(c = leftB; c < rightB; c++)
		 	{  /* Cells that might be in pixel */
   			    POINT2D *inputCell;  /* polygon input cell */

			    if(r < 0 || RgetNrRows(X) <= r || c < 0 ||
			       RgetNrCols(X) <= c)
			    	continue;

   			    /* Top left & right, bottom left & right */
   			    RrowCol2Coords(X, r, c, &tlX2, &tlY2);
   			    RrowCol2Coords(X, r, c+1, &trX2, &trY2);
   			    RrowCol2Coords(X, r+1, c, &blX2, &blY2);
   			    RrowCol2Coords(X, r+1, c+1, &brX2, &brY2);
			    inputCell = PutInPol(tlX2, tlY2, trX2, trY2,
					brX2, brY2, blX2, blY2);
			    if(inputCell == NULL)
				return 1;

			    POSTCOND(inputCell[0].x == inputCell[nr].x);
			    POSTCOND(inputCell[0].y == inputCell[nr].y);

			    /* Add item to list for cell */
			    if(AddCell(&list, raster, &nrList, inputCell,
				  outputCell, currRow, X, nrMaps,
				   (size_t)c, nrCoverCells, aligned, angle))
				      return 1;
			    Free(inputCell);	/* deallocate */
		 	}
		}
	}	 

	/* calculate output value of pixel according value scale */
	vs = RgetValueScale(in[0]);
	if(vs != VS_DIRECTION)
		CalcScalarOut(out, (size_t)rOut, (size_t)cOut, nrList, list, nrCoverCells, nrMaps);
	else
		CalcDirectionOut(out, (size_t) rOut, (size_t) cOut, nrList, list, nrCoverCells, nrMaps);

	Free(outputCell);		/* deallocate */
	Free(list);			/* deallocate */
	return 0;			/* successfully terminated */
}