[DBP / GDK] Angular size of an object in PIXELS - small angle formula

Author

Message

Morcilla

21

Years of Service

User Offline

Joined: 1st Dec 2002

Location: Spain

Posted: 12th Feb 2010 14:06 Edited at: 12th Feb 2010 14:07

Link

Hi all,

This code calculates the size in pixels of an object in the screen, using the "small angle approximation" formula.

It works for any camera Field Of View angle (FOV).
Ideal for Level Of Detail (LOD) systems based on size in pixels in screen (rather than based directly on distance calculus).

It allows to precisely find out if an object is not visible anymore (pixel size < 1), or when it has a particular size on the screen.
Particularly useful for LOD binocular view, or any other changing FOV scenery.

Also suitable for many other uses, as line of sight occlusion, combined with the x,y screen coordinates:
Knowing the 2d screen coordinates, the size in pixels, and the distance, it can be known if an object is visually occluded by another one.

Note on accuracy: This code is based on the "small angle approximation" formula, a simplification of the laws of trigonometry which only returns an approximated value. The greater the angle measured, or the FOV angle, the greater the error in the returned value.
Despite of this, accuracy should suffice for a standard gaming environment.

DBPro code version:

remstart
////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
//////// This code calculates the size in pixels of an object in the screen,
//////// using the "small angle approximation" formula.
////////
//////// It works for any camera Field Of View angle (FOV).
//////// Ideal for Level Of Detail (LOD) systems based on size in pixels in screen
//////// (rather than based directly on distance# calculus).
//////// It allows to precisely find out if an object is not visible anymore (pixel size < 1),
//////// or when it has a particular size on the screen.
////////
//////// Particularly useful for LOD binocular view, or any other changing FOV scenery.
////////
//////// Also suitable for many other uses, as line of sight occlusion,
//////// combined with the x,y screen coordinates:
//////// Knowing the 2d screen coordinates, the size in pixels, and the distance#,
//////// it can be known if an object is visually occluded by another one.
////////
//////// Note on accuracy: This code is based on the "small angle approximation" formula,
//////// a simplification of the laws of trigonometry which only returns an approximated value.
//////// The greater the angle measured, or the FOV angle,
//////// the greater the error in the returned value.
//////// Despite of this, accuracy should suffice for a standard gaming environment.
////////
//////// 2010, Manuel Perez de Lema Lopez - MPL3D Team.
//////// If you use any portion of this code in a program, please credit "MPL3D".
////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
remend

angular_size# = 0.0
   Diameter# = 200.0
   distance# = 0.0
   camera_FOV# = 55.0
   pixel_size# = 0.0

Sync On
   Sync Rate 30
   Set Display Mode 640,480,32
   Set Window On

Make Object Sphere  1, Diameter#/2.0, 10, 10
   Position Object     1, 0.0, Diameter#/8.0, 0.0

Set Camera Range 1.0, 100000.0
   Set Camera FOV   camera_FOV#

do

if ShiftKey()
         camera_FOV# = camera_FOV# + 0.5
         Set Camera FOV  camera_FOV#
      endif

if ControlKey()
         camera_FOV# = camera_FOV# - 0.5
         Set Camera FOV camera_FOV#
      endif

Control Camera Using ArrowKeys 0, 100.0, 0.5

distance# = (Object Position X(1) - Camera Position X()) * (Object Position X(1) - Camera Position X()) + (Object Position Y(1) - Camera Position Y()) * (Object Position Y(1) - Camera Position Y()) + (Object Position Z(1) - Camera Position Z()) * (Object Position Z(1) - Camera Position Z())

distance# = sqrt(distance#)

remstart
      //Calculate angular size:
      //
      //d = distance# to the object
      //D = Diameter# of the object
      //Angle A ~ (D/d) x 57.3 deg.
      //Note: This is called the "small angle approximation"
      remend

angular_size# = ( Diameter# / distance# ) * 57.3

remstart
      //Tranform into pixels:
      //
      // camera_FOV#   º (degrees)      ->   Screen height   (pixels)
      // Angular size º (degrees)      ->   'X' Object size   (pixels)
      //
      //then,
      //
      // 'X' (pixels) = ( angular_size# (degrees) * Screen height (pixels) ) / camera_FOV# (degrees)
      remend

pixel_size# = ( angular_size# * Screen Height() ) / camera_FOV#
      pixel_size# = pixel_size# / 2.0

Set Cursor      0,10
      Print Screen FPS()

Print "camera_FOV# = "  + Str$(camera_FOV#)

Print "distance# = "  + Str$(distance#)

Print "angular_size = "  + Str$(angular_size#)

Print "pixel_size# = "  + Str$(pixel_size#)

Sync

loop

end

+ Code Snippet

remstart
////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
//////// This code calculates the size in pixels of an object in the screen,
//////// using the "small angle approximation" formula.
////////
//////// It works for any camera Field Of View angle (FOV).
//////// Ideal for Level Of Detail (LOD) systems based on size in pixels in screen
//////// (rather than based directly on distance# calculus).
//////// It allows to precisely find out if an object is not visible anymore (pixel size < 1),
//////// or when it has a particular size on the screen.
////////
//////// Particularly useful for LOD binocular view, or any other changing FOV scenery.
////////
//////// Also suitable for many other uses, as line of sight occlusion,
//////// combined with the x,y screen coordinates:
//////// Knowing the 2d screen coordinates, the size in pixels, and the distance#,
//////// it can be known if an object is visually occluded by another one.
////////
//////// Note on accuracy: This code is based on the "small angle approximation" formula,
//////// a simplification of the laws of trigonometry which only returns an approximated value.
//////// The greater the angle measured, or the FOV angle,
//////// the greater the error in the returned value.
//////// Despite of this, accuracy should suffice for a standard gaming environment.
////////
//////// 2010, Manuel Perez de Lema Lopez - MPL3D Team.
//////// If you use any portion of this code in a program, please credit "MPL3D".
////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
remend

   angular_size# = 0.0
   Diameter# = 200.0
   distance# = 0.0
   camera_FOV# = 55.0
   pixel_size# = 0.0

   Sync On
   Sync Rate 30
   Set Display Mode 640,480,32
   Set Window On

   Make Object Sphere  1, Diameter#/2.0, 10, 10
   Position Object     1, 0.0, Diameter#/8.0, 0.0

   Set Camera Range 1.0, 100000.0
   Set Camera FOV   camera_FOV#

   do

      if ShiftKey()
         camera_FOV# = camera_FOV# + 0.5
         Set Camera FOV  camera_FOV#
      endif

      if ControlKey()
         camera_FOV# = camera_FOV# - 0.5
         Set Camera FOV camera_FOV#
      endif

      Control Camera Using ArrowKeys 0, 100.0, 0.5

      distance# = (Object Position X(1) - Camera Position X()) * (Object Position X(1) - Camera Position X()) + (Object Position Y(1) - Camera Position Y()) * (Object Position Y(1) - Camera Position Y()) + (Object Position Z(1) - Camera Position Z()) * (Object Position Z(1) - Camera Position Z())

      distance# = sqrt(distance#)

      remstart
      //Calculate angular size:
      //
      //d = distance# to the object
      //D = Diameter# of the object
      //Angle A ~ (D/d) x 57.3 deg.
      //Note: This is called the "small angle approximation"
      remend

      angular_size# = ( Diameter# / distance# ) * 57.3

      remstart
      //Tranform into pixels:
      //
      // camera_FOV#   º (degrees)      ->   Screen height   (pixels)
      // Angular size º (degrees)      ->   'X' Object size   (pixels)
      //
      //then,
      //
      // 'X' (pixels) = ( angular_size# (degrees) * Screen height (pixels) ) / camera_FOV# (degrees)
      remend

      pixel_size# = ( angular_size# * Screen Height() ) / camera_FOV#
      pixel_size# = pixel_size# / 2.0

      Set Cursor      0,10
      Print Screen FPS()

      Print "camera_FOV# = "  + Str$(camera_FOV#)

      Print "distance# = "  + Str$(distance#)

      Print "angular_size = "  + Str$(angular_size#)

      Print "pixel_size# = "  + Str$(pixel_size#)

      Sync

   loop

end

DGDK code version:

////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
//////// This code calculates the size in pixels of an object in the screen,
//////// using the "small angle approximation" formula.
////////
//////// It works for any camera Field Of View angle (FOV).
//////// Ideal for Level Of Detail (LOD) systems based on size in pixels in screen
//////// (rather than based directly on distance calculus). 
//////// It allows to precisely find out if an object is not visible anymore (pixel size < 1),  
//////// or when it has a particular size on the screen.
////////
//////// Particularly useful for LOD binocular view, or any other changing FOV scenery.
////////
//////// Also suitable for many other uses, as line of sight occlusion,
//////// combined with the x,y screen coordinates:
//////// Knowing the 2d screen coordinates, the size in pixels, and the distance,
//////// it can be known if an object is visually occluded by another one.
////////
//////// Note on accuracy: This code is based on the "small angle approximation" formula,
//////// a simplification of the laws of trigonometry which only returns an approximated value.
//////// The greater the angle measured, or the FOV angle,
//////// the greater the error in the returned value.
//////// Despite of this, accuracy should suffice for a standard gaming environment.
////////
//////// 2010, Manuel Perez de Lema Lopez - MPL3D Team.
//////// If you use any portion of this code in a program, please credit "MPL3D".
////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////

#include "windows.h"
#include "DarkGDK.h"
#include "math.h"
#include "stdio.h"

void DarkGDK ( void )
{
	char text_line[256];
	
	float angular_size = 0.0f;	
	float Diameter = 200.0f; 	 
	float distance = 0.0f;
	float camera_FOV = 55.0f;
	float pixel_size = 0.0f;

dbSyncOn();
	dbSyncRate(30);
	dbSetDisplayMode (640,480,32);
	dbSetWindowOn();

dbMakeObjectSphere ( 1, Diameter/2.0f, 10, 10 );
	dbPositionObject   ( 1, 0.0f, Diameter/8.0f, 0.0f);

dbSetCameraRange (1.0f, 100000.0f );
	dbSetCameraFOV( camera_FOV );
	
	while ( LoopGDK ( ) )
	{

if (dbShiftKey())
		{
			camera_FOV = camera_FOV + 0.5f ;
			dbSetCameraFOV( camera_FOV );
		}

if (dbControlKey())
		{
			camera_FOV = camera_FOV - 0.5f ;
			dbSetCameraFOV( camera_FOV );
		}
		
		dbControlCameraUsingArrowKeys(0, 100.0f, 0.5f);

distance = (dbObjectPositionX(1) - dbCameraPositionX()) * (dbObjectPositionX(1) - dbCameraPositionX()) 
				 + (dbObjectPositionY(1) - dbCameraPositionY()) * (dbObjectPositionY(1) - dbCameraPositionY()) 
				 + (dbObjectPositionZ(1) - dbCameraPositionZ()) * (dbObjectPositionZ(1) - dbCameraPositionZ()) ;

distance = sqrt(distance);

//Calculate angular size:
		//
		//d = distance to the object
		//D = Diameter of the object
		//Angle A ~ (D/d) x 57.3 deg.
		//Note: This is called the "small angle approximation"
		
		angular_size = ( Diameter / distance ) * 57.3f;
		
		//Tranform into pixels:
		//
		// camera_FOV	º (degrees)		->	Screen height	(pixels)
		// Angular size º (degrees)		->	'X' Object size	(pixels)
		//
		//then,
		//
		// 'X' (pixels) = ( angular_size (degrees) * Screen height (pixels) ) / camera_FOV (degrees)

pixel_size = ( angular_size * dbScreenHeight() ) / camera_FOV ;
		pixel_size = pixel_size / 2.0f;

dbSetCursor		(0,10);
		dbPrint ((float) dbScreenFPS());

sprintf(text_line, "camera_FOV = %f" , camera_FOV);
		dbPrint (text_line);

sprintf(text_line, "distance = %f" , distance);
		dbPrint (text_line);

sprintf(text_line, "angular_size = %f" , angular_size);
		dbPrint (text_line);

sprintf(text_line, "pixel_size = %f" , pixel_size);
		dbPrint (text_line);

dbSync();

} //end while

}// end DarkGDK

+ Code Snippet

////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
//////// This code calculates the size in pixels of an object in the screen,
//////// using the "small angle approximation" formula.
////////
//////// It works for any camera Field Of View angle (FOV).
//////// Ideal for Level Of Detail (LOD) systems based on size in pixels in screen
//////// (rather than based directly on distance calculus). 
//////// It allows to precisely find out if an object is not visible anymore (pixel size < 1),  
//////// or when it has a particular size on the screen.
////////
//////// Particularly useful for LOD binocular view, or any other changing FOV scenery.
////////
//////// Also suitable for many other uses, as line of sight occlusion,
//////// combined with the x,y screen coordinates:
//////// Knowing the 2d screen coordinates, the size in pixels, and the distance,
//////// it can be known if an object is visually occluded by another one.
////////
//////// Note on accuracy: This code is based on the "small angle approximation" formula,
//////// a simplification of the laws of trigonometry which only returns an approximated value.
//////// The greater the angle measured, or the FOV angle,
//////// the greater the error in the returned value.
//////// Despite of this, accuracy should suffice for a standard gaming environment.
////////
//////// 2010, Manuel Perez de Lema Lopez - MPL3D Team.
//////// If you use any portion of this code in a program, please credit "MPL3D".
////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////

#include "windows.h"
#include "DarkGDK.h"
#include "math.h"
#include "stdio.h"

void DarkGDK ( void )
{
	char text_line[256];
	
	float angular_size = 0.0f;	
	float Diameter = 200.0f; 	 
	float distance = 0.0f;
	float camera_FOV = 55.0f;
	float pixel_size = 0.0f;

	dbSyncOn();
	dbSyncRate(30);
	dbSetDisplayMode (640,480,32);
	dbSetWindowOn();

	dbMakeObjectSphere ( 1, Diameter/2.0f, 10, 10 );
	dbPositionObject   ( 1, 0.0f, Diameter/8.0f, 0.0f);

	dbSetCameraRange (1.0f, 100000.0f );
	dbSetCameraFOV( camera_FOV );
	
	while ( LoopGDK ( ) )
	{

		if (dbShiftKey())
		{
			camera_FOV = camera_FOV + 0.5f ;
			dbSetCameraFOV( camera_FOV );
		}

		if (dbControlKey())
		{
			camera_FOV = camera_FOV - 0.5f ;
			dbSetCameraFOV( camera_FOV );
		}
		
		dbControlCameraUsingArrowKeys(0, 100.0f, 0.5f);

		distance = (dbObjectPositionX(1) - dbCameraPositionX()) * (dbObjectPositionX(1) - dbCameraPositionX()) 
				 + (dbObjectPositionY(1) - dbCameraPositionY()) * (dbObjectPositionY(1) - dbCameraPositionY()) 
				 + (dbObjectPositionZ(1) - dbCameraPositionZ()) * (dbObjectPositionZ(1) - dbCameraPositionZ()) ;

		distance = sqrt(distance);

		//Calculate angular size:
		//
		//d = distance to the object
		//D = Diameter of the object
		//Angle A ~ (D/d) x 57.3 deg.
		//Note: This is called the "small angle approximation"
		
		angular_size = ( Diameter / distance ) * 57.3f;
		
		//Tranform into pixels:
		//
		// camera_FOV	º (degrees)		->	Screen height	(pixels)
		// Angular size º (degrees)		->	'X' Object size	(pixels)
		//
		//then,
		//
		// 'X' (pixels) = ( angular_size (degrees) * Screen height (pixels) ) / camera_FOV (degrees)

		pixel_size = ( angular_size * dbScreenHeight() ) / camera_FOV ;
		pixel_size = pixel_size / 2.0f;

		dbSetCursor		(0,10);
		dbPrint ((float) dbScreenFPS());

		sprintf(text_line, "camera_FOV = %f" , camera_FOV);
		dbPrint (text_line);

		sprintf(text_line, "distance = %f" , distance);
		dbPrint (text_line);

		sprintf(text_line, "angular_size = %f" , angular_size);
		dbPrint (text_line);

		sprintf(text_line, "pixel_size = %f" , pixel_size);
		dbPrint (text_line);

		dbSync();

	} //end while

}// end DarkGDK

The maths behind the size in pixels is very simple using the small angle formula, just a couple of multiplications, so don't be afraid to use it

A note on the DBPro version, I have noticed that DBPro's screen resolution includes the window menu, so the pixel ratio looks weird here. To correct this, fix the camera aspect by adding the menu size (8x34 pixels), for example 640x480 would be:

+ Code Snippet

Set Camera Aspect (640.0-8.0) / (480.0 - 34.0)

Not a thing to worry if using the right full screen resolution.

DGDK image:

If you use any portion of this code in a program, please credit "MPL3D", I got a brand name to maintain

Attachments

Login to view attachments

Back to top

Profile PM Email Website

Morcilla

21

Years of Service

User Offline

Joined: 1st Dec 2002

Location: Spain

Posted: 22nd Apr 2010 14:39 Edited at: 22nd Apr 2010 18:38

Link

This is an example application of the pixel size algorithm, a basic custom texture LOD system.

The code calculates the pixel size of a plane and then textures the object with the corresponding texture size.
In the example these are 800x600, 400x300, 200x150 and 100x75. Of course this is just the basic idea, and ideally it should be adapted to your own needs.

This is the DGDK code version, but it is quite simple to translate it to DBPro (no C++ features used):

////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
//////// This code calculates the size in pixels of an object in the screen,					//////// 
//////// using the "small angle approximation" formula.											//////// 
////////																						//////// 
//////// It works for any camera Field Of View angle (FOV).										//////// 
//////// Ideal for Level Of Detail (LOD) systems based on size in pixels in screen				//////// 
//////// (rather than based directly on distance calculus).										//////// 
//////// It allows to precisely find out if an object is not visible anymore (pixel size < 1),  //////// 
//////// or when it has a particular size on the screen.										//////// 
////////																						//////// 
//////// Particularly useful for LOD binocular view, or any other changing FOV scenery.			////////
////////																						//////// 
//////// Also suitable for many other uses, as line of sight occlusion,							//////// 
//////// combined with the x,y screen coordinates:												//////// 
//////// Knowing the 2d screen coordinates, the size in pixels, and the distance,				//////// 
//////// it can be known if an object is visually occluded by another one.						//////// 
////////																						//////// 
//////// Note on accuracy: This code is based on the "small angle approximation" formula,		//////// 
//////// a simplification of the laws of trigonometry which only returns an approximated value.	////////
//////// The greater the angle measured, or the FOV angle,										////////
//////// the greater the error in the returned value.											//////// 
//////// Despite of this, accuracy should suffice for a standard gaming environment.			//////// 
////////																						////////
//////// 2010, Manuel Perez de Lema Lopez - MPL3D Team.											////////
//////// If you use any portion of this code in a program, please credit "MPL3D".				////////
////////																						//////// 
////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////

#include "windows.h"
#include "DarkGDK.h"
#include "math.h"
#include "stdio.h"

void DarkGDK ( void )
{
	char text_line[256];
	
	float angular_size = 0.0f;	
	float Diameter = 200.0f; 	 
	float distance = 0.0f;
	float camera_FOV = 55.0f;
	float pixel_size = 0.0f;

dbSyncOn();
	dbSyncRate(30);
	dbSetDisplayMode (640,480,32);
	dbSetWindowOn();

//Make a plane to texture
	dbMakeObjectPlane (1, Diameter, Diameter);
	dbPositionObject  (1, 0.0f, Diameter/8.0f, 0.0f);

dbSetCameraRange (1.0f, 100000.0f );
	dbSetCameraFOV( camera_FOV );
	
	//Set image IDs
	int image_ID_800x600 = 1;
	int image_ID_400x300 = 2;
	int image_ID_200x150 = 3;
	int image_ID_100x75  = 4;

//Current image Id
	int current_image_ID = 1;
	
	//Load images
	//They could be loaded as well on the run, and keep the same texture ID.
	dbLoadImage ("Winter_800x600.jpg", image_ID_800x600, 1);
	dbLoadImage ("Winter_400x300.jpg", image_ID_400x300, 1);
	dbLoadImage ("Winter_200x150.jpg", image_ID_200x150, 1);
	dbLoadImage ("Winter_100x75.jpg",  image_ID_100x75 , 1);

//Default texture for plane object
	dbTextureObject (1, image_ID_800x600);

while ( LoopGDK ( ) )
	{

//Increase FOV with Shift key
		if (dbShiftKey())
		{
			camera_FOV = camera_FOV + 0.5f ;
			dbSetCameraFOV( camera_FOV );
		}

//Decrease FOV with Control key
		if (dbControlKey())
		{
			camera_FOV = camera_FOV - 0.5f ;
			dbSetCameraFOV( camera_FOV );
		}
		
		//Control Camera Using Arrow Keys
		dbControlCameraUsingArrowKeys(0, 10.0f, 0.5f);

//Calculate distance to object
		distance = (dbObjectPositionX(1) - dbCameraPositionX()) * (dbObjectPositionX(1) - dbCameraPositionX()) 
				 + (dbObjectPositionY(1) - dbCameraPositionY()) * (dbObjectPositionY(1) - dbCameraPositionY()) 
				 + (dbObjectPositionZ(1) - dbCameraPositionZ()) * (dbObjectPositionZ(1) - dbCameraPositionZ()) ;

distance = sqrt(distance);

//Calculate angular size:
		//
		//d = distance to the object
		//D = Diameter of the object
		//Angle A ~ (D/d) x 57.3 deg.
		//Note: This is called the "small angle approximation"
		
		angular_size = ( Diameter / distance ) * 57.3f;
		
		//Tranform into pixels:
		//
		// camera_FOV	º (degrees)		->	Screen height	(pixels)
		// Angular size º (degrees)		->	'X' Object size	(pixels)
		//
		//then,
		//
		// 'X' (pixels) = ( angular_size (degrees) * Screen height (pixels) ) / camera_FOV (degrees)

pixel_size = ( angular_size * dbScreenHeight() ) / camera_FOV ;

//Apply LOD texture based on pixel size on screen
		if (pixel_size < 75)
		{
			//Only apply texture if it is not already applied
			if (current_image_ID != image_ID_100x75)
			{
				dbTextureObject (1, image_ID_100x75);
				current_image_ID =  image_ID_100x75; 
			}
		}
		else
		{
			if (pixel_size < 150)
			{
				//Only apply texture if it is not already applied
				if (current_image_ID != image_ID_200x150)
				{
					dbTextureObject (1, image_ID_200x150);
					current_image_ID  = image_ID_200x150; 
				}

}
			else
			{
				if (pixel_size < 300)
				{
					//Only apply texture if it is not already applied
					if (current_image_ID != image_ID_400x300)
					{
						dbTextureObject (1, image_ID_400x300);
						current_image_ID  = image_ID_400x300; 
					}
				}
				else
				{
					//Only apply texture if it is not already applied
					if (current_image_ID != image_ID_800x600)
					{
						dbTextureObject (1, image_ID_800x600);
						current_image_ID  = image_ID_800x600; 
					}
				}
			}
		}

//Print data
		dbSetCursor		(0,0);

dbPrint ("Use Arrow Keys to move.");
		dbPrint ("Shift key to increase camera FOV.");
		dbPrint ("Control key to decrease camera FOV.");
		dbPrint ();

sprintf(text_line, "camera_FOV = %f" , camera_FOV);
		dbPrint (text_line);

sprintf(text_line, "distance = %f" , distance);
		dbPrint (text_line);

sprintf(text_line, "angular_size = %f" , angular_size);
		dbPrint (text_line);

sprintf(text_line, "pixel_size = %f" , pixel_size);
		dbPrint (text_line);
		dbPrint ();

//Print current texture
		if (current_image_ID == 1)
		{
			dbPrint ("Texture used: 800x600");
		}
		else
		{
			if (current_image_ID == 2)
			{
				dbPrint ("Texture used: 400x300");
			}
			else
			{
				if (current_image_ID == 3)
				{
					dbPrint ("Texture used: 200x150");
				}
				else
				{
					dbPrint ("Texture used: 100x75");
				}
			}
		}

dbSync();

} //end while

}// end DarkGDK

+ Code Snippet

////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
//////// This code calculates the size in pixels of an object in the screen,					//////// 
//////// using the "small angle approximation" formula.											//////// 
////////																						//////// 
//////// It works for any camera Field Of View angle (FOV).										//////// 
//////// Ideal for Level Of Detail (LOD) systems based on size in pixels in screen				//////// 
//////// (rather than based directly on distance calculus).										//////// 
//////// It allows to precisely find out if an object is not visible anymore (pixel size < 1),  //////// 
//////// or when it has a particular size on the screen.										//////// 
////////																						//////// 
//////// Particularly useful for LOD binocular view, or any other changing FOV scenery.			////////
////////																						//////// 
//////// Also suitable for many other uses, as line of sight occlusion,							//////// 
//////// combined with the x,y screen coordinates:												//////// 
//////// Knowing the 2d screen coordinates, the size in pixels, and the distance,				//////// 
//////// it can be known if an object is visually occluded by another one.						//////// 
////////																						//////// 
//////// Note on accuracy: This code is based on the "small angle approximation" formula,		//////// 
//////// a simplification of the laws of trigonometry which only returns an approximated value.	////////
//////// The greater the angle measured, or the FOV angle,										////////
//////// the greater the error in the returned value.											//////// 
//////// Despite of this, accuracy should suffice for a standard gaming environment.			//////// 
////////																						////////
//////// 2010, Manuel Perez de Lema Lopez - MPL3D Team.											////////
//////// If you use any portion of this code in a program, please credit "MPL3D".				////////
////////																						//////// 
////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////

#include "windows.h"
#include "DarkGDK.h"
#include "math.h"
#include "stdio.h"

void DarkGDK ( void )
{
	char text_line[256];
	
	float angular_size = 0.0f;	
	float Diameter = 200.0f; 	 
	float distance = 0.0f;
	float camera_FOV = 55.0f;
	float pixel_size = 0.0f;

	dbSyncOn();
	dbSyncRate(30);
	dbSetDisplayMode (640,480,32);
	dbSetWindowOn();

	//Make a plane to texture
	dbMakeObjectPlane (1, Diameter, Diameter);
	dbPositionObject  (1, 0.0f, Diameter/8.0f, 0.0f);

	dbSetCameraRange (1.0f, 100000.0f );
	dbSetCameraFOV( camera_FOV );
	
	//Set image IDs
	int image_ID_800x600 = 1;
	int image_ID_400x300 = 2;
	int image_ID_200x150 = 3;
	int image_ID_100x75  = 4;

	//Current image Id
	int current_image_ID = 1;
	
	//Load images
	//They could be loaded as well on the run, and keep the same texture ID.
	dbLoadImage ("Winter_800x600.jpg", image_ID_800x600, 1);
	dbLoadImage ("Winter_400x300.jpg", image_ID_400x300, 1);
	dbLoadImage ("Winter_200x150.jpg", image_ID_200x150, 1);
	dbLoadImage ("Winter_100x75.jpg",  image_ID_100x75 , 1);

	//Default texture for plane object
	dbTextureObject (1, image_ID_800x600);

	while ( LoopGDK ( ) )
	{

		//Increase FOV with Shift key
		if (dbShiftKey())
		{
			camera_FOV = camera_FOV + 0.5f ;
			dbSetCameraFOV( camera_FOV );
		}

		//Decrease FOV with Control key
		if (dbControlKey())
		{
			camera_FOV = camera_FOV - 0.5f ;
			dbSetCameraFOV( camera_FOV );
		}
		
		//Control Camera Using Arrow Keys
		dbControlCameraUsingArrowKeys(0, 10.0f, 0.5f);

		//Calculate distance to object
		distance = (dbObjectPositionX(1) - dbCameraPositionX()) * (dbObjectPositionX(1) - dbCameraPositionX()) 
				 + (dbObjectPositionY(1) - dbCameraPositionY()) * (dbObjectPositionY(1) - dbCameraPositionY()) 
				 + (dbObjectPositionZ(1) - dbCameraPositionZ()) * (dbObjectPositionZ(1) - dbCameraPositionZ()) ;

		distance = sqrt(distance);

		//Calculate angular size:
		//
		//d = distance to the object
		//D = Diameter of the object
		//Angle A ~ (D/d) x 57.3 deg.
		//Note: This is called the "small angle approximation"
		
		angular_size = ( Diameter / distance ) * 57.3f;
		
		//Tranform into pixels:
		//
		// camera_FOV	º (degrees)		->	Screen height	(pixels)
		// Angular size º (degrees)		->	'X' Object size	(pixels)
		//
		//then,
		//
		// 'X' (pixels) = ( angular_size (degrees) * Screen height (pixels) ) / camera_FOV (degrees)

		pixel_size = ( angular_size * dbScreenHeight() ) / camera_FOV ;


		//Apply LOD texture based on pixel size on screen
		if (pixel_size < 75)
		{
			//Only apply texture if it is not already applied
			if (current_image_ID != image_ID_100x75)
			{
				dbTextureObject (1, image_ID_100x75);
				current_image_ID =  image_ID_100x75; 
			}
		}
		else
		{
			if (pixel_size < 150)
			{
				//Only apply texture if it is not already applied
				if (current_image_ID != image_ID_200x150)
				{
					dbTextureObject (1, image_ID_200x150);
					current_image_ID  = image_ID_200x150; 
				}

			}
			else
			{
				if (pixel_size < 300)
				{
					//Only apply texture if it is not already applied
					if (current_image_ID != image_ID_400x300)
					{
						dbTextureObject (1, image_ID_400x300);
						current_image_ID  = image_ID_400x300; 
					}
				}
				else
				{
					//Only apply texture if it is not already applied
					if (current_image_ID != image_ID_800x600)
					{
						dbTextureObject (1, image_ID_800x600);
						current_image_ID  = image_ID_800x600; 
					}
				}
			}
		}


		//Print data
		dbSetCursor		(0,0);		

		dbPrint ("Use Arrow Keys to move.");
		dbPrint ("Shift key to increase camera FOV.");
		dbPrint ("Control key to decrease camera FOV.");
		dbPrint ();

		sprintf(text_line, "camera_FOV = %f" , camera_FOV);
		dbPrint (text_line);

		sprintf(text_line, "distance = %f" , distance);
		dbPrint (text_line);

		sprintf(text_line, "angular_size = %f" , angular_size);
		dbPrint (text_line);

		sprintf(text_line, "pixel_size = %f" , pixel_size);
		dbPrint (text_line);
		dbPrint ();

		//Print current texture
		if (current_image_ID == 1)
		{
			dbPrint ("Texture used: 800x600");
		}
		else
		{
			if (current_image_ID == 2)
			{
				dbPrint ("Texture used: 400x300");
			}
			else
			{
				if (current_image_ID == 3)
				{
					dbPrint ("Texture used: 200x150");
				}
				else
				{
					dbPrint ("Texture used: 100x75");
				}
			}
		}

		dbSync();

	} //end while

}// end DarkGDK

Also attached the DGDK project with a compiled executable.

I will keep on posting some more applications of the pixel size method here, hope you find them useful.

Attachments

Login to view attachments

Back to top

Profile PM Email Website

baxslash

Valued Member

Bronze Codemaster

17

Years of Service

User Offline

Joined: 26th Dec 2006

Location: Duffield

Posted: 28th Apr 2010 15:27

Link

Doesn't this just estimate the size of the object based on diameter and distance from camera though? What if your object is long and thin, or square?

I was hoping it would say how many actual pixels of your object are visible...

Back to top

Profile PM Email

Morcilla

21

Years of Service

User Offline

Joined: 1st Dec 2002

Location: Spain

Posted: 29th Apr 2010 14:02 Edited at: 29th Apr 2010 14:04

Link

You are right, this is ideal for square or round objects, that have equal x/y/z dimensions.

If the object is, for example, 'long and thin', then I recommend to use the largest, the shortest, or the average size to calculate the pixel size, it depends on each particular case.

Quote: "I was hoping it would say how many actual pixels of your object are visible... "

Well, this is a fast calculus. It doesn't perform the integration of complex shapes.

However, the pixel size gives us a criteria to decide the LOD level.
Take for example the DBPro LOD command:

ADD LOD TO OBJECT Object Number, LOD Object, LOD Level, LOD Distance

Now, what should be that 'LOD distance'? 10 units? 100 units? 1000?
With the pixel size you can calculate at which distance the object will have xx pixels in the screen.
So instead of figuring out the distance, you can set it, for example, to a distance when the object is 100 pixels wide.
If the object is 'long and thin', well, this was a problem already with the DBPro function. As said, this calculus is just fast, not accurate.

This is a DBPro function that calculates at which distance an object will have a certain pixel size:

+ Code Snippet

  angular_size# = 0.0
  Diameter# = 200.0
  distance# = 0.0
  camera_FOV# = 55.0
  pixel_size# = 100.0

function Calculate_Distance_For_Pixel_Size(Diameter#, camera_FOV#, pixel_size#)

  angular_size# =  (pixel_size# * camera_FOV#) / Screen Height()

  distance# = ( Diameter# * 57.3 ) /  angular_size#

endfunction

It should be used to determine the distance parameter for the 'ADD LOD TO OBJECT' DBPro function.

Back to top

Profile PM Email Website

Sorry your browser is not supported!

Code Snippets / [DBP / GDK] Angular size of an object in PIXELS - small angle formula

Attachments

Attachments