ALMaSS: BinaryMapBase Class Reference

•All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages

#include <BinaryMapBase.h>

Inheritance diagram for BinaryMapBase:

Public Member Functions
	BinaryMapBase (unsigned int a_width, unsigned int a_height, unsigned int a_resolution, unsigned int a_noValues)

	~BinaryMapBase ()

uint64	GetValue (unsigned a_x, unsigned a_y)

void	SetValue (unsigned a_x, unsigned a_y, unsigned a_value)

void	ClearValue (unsigned a_x, unsigned a_y)

void	ClearMap ()

Protected Attributes
uint64 *	m_map

unsigned int	m_height

unsigned int	m_width

unsigned int	m_colourRes

unsigned int	m_colourScaler

unsigned int	m_resolution

unsigned int	m_resolutionscaler

unsigned int	m_maskbits

unsigned int	m_maplength

uint64	m_mask

Constructor & Destructor Documentation

◆ BinaryMapBase()

BinaryMapBase::BinaryMapBase	(	unsigned int	a_width,
		unsigned int	a_height,
		unsigned int	a_resolution,
		unsigned int	a_noValues
	)

 {
     // Assign member variables
     m_width = a_width;
     m_height = a_height;
     m_colourRes = a_noValues;
     m_resolution = a_resolution;
     // 2 = 1, 4 = 2, 8 = 3 etc..
     m_resolutionscaler = 0;
     unsigned int n=m_resolution;
     do {
         n = n >> 1;
         m_resolutionscaler++;
     } while (n>0);
     m_resolutionscaler--;
     m_colourScaler = 0;
     n=m_colourRes;
     do {
         n = n >> 1;
         m_colourScaler++;
     } while (n>0);
     m_colourScaler--;
  
     // The total number of 64bit integers needed is height x width / 64 (rounded up);
     // But we need to take the resolution into account too - hence:
     // ( (height x width)/(resolution*resolution) ) / 64, then add one in case there is a fractional part
     // Then we also need to have the size of the colour resolution calculated in here.
     m_maplength = ( ( ( m_width * m_height * m_colourScaler ) / ( m_resolution * m_resolution )) / 64 ) + 1;
     // Need to adjust m_width & m_height to match resolution
     m_width = m_width >> m_resolutionscaler;
     m_height = m_height >> m_resolutionscaler;
     m_map = new uint64[m_maplength];
  
     // create the mask
     m_mask = m_colourRes-1;
     m_maskbits = m_colourScaler -1;
     ClearMap();
 }

References ClearMap(), m_colourRes, m_colourScaler, m_height, m_map, m_maplength, m_mask, m_maskbits, m_resolution, m_resolutionscaler, and m_width.

◆ ~BinaryMapBase()

BinaryMapBase::~BinaryMapBase ( )

 {
     ;
 }

Member Function Documentation

◆ ClearMap()

void BinaryMapBase::ClearMap ( )

 {
     for (unsigned int i = 0; i < m_maplength; i++) m_map[i]=0;
 }

References m_map, and m_maplength.

Referenced by BinaryMapBase(), and TrapLineMap::Init().

◆ ClearValue()

void BinaryMapBase::ClearValue	(	unsigned	a_x,
		unsigned	a_y
	)

Avoids passing one parameter compared to SetValue(unsigned, unsigned, unsigned)

 {
     // To find an x/y co-ordinate:
     // We need to find the 64-bit int that we are in, then the bit or bytes we need
     unsigned int ref = ( ( ( a_y >> m_resolutionscaler ) * m_width ) + ( a_x >> m_resolutionscaler ) ) * m_colourScaler;
     // ref holds the first bit of information we need, i.e. the location within m_map in terms of element number.
     // Next we need to figure out which uint64 this is in.....
     unsigned int index = ref >> 6; // ....so divide by 64
     // get the value from this location to a temporary variable
     uint64 newvalue = m_map[index];
     // identify the bits we are interested in
     uint64 bits = ( ref & 63 );
     // Our mask is sized based on the colours represented 1 - binary, 2 - 4, 4 - 16 , 8 - 256 (NB only powers of 2 are allowed).
     // The mask is created in the constructor.
     // So we need to shift our mask to cover the correct bits.
     uint64 mask = ~( m_mask << bits );
     // Blank out any current values
     newvalue = newvalue & mask;
     m_map[index] = newvalue;
     ;
 }

References m_colourScaler, m_map, m_mask, m_resolutionscaler, and m_width.

◆ GetValue()

uint64 BinaryMapBase::GetValue	(	unsigned	a_x,
		unsigned	a_y
	)

 {
     // To find an x/y co-ordinate:
     // We need to find the 64-bit int that we are in, then the bit or bytes we need
     unsigned int ref = ( ( ( a_y >> m_resolutionscaler ) * m_width ) + ( a_x >> m_resolutionscaler ) ) * m_colourScaler;
     // ref holds the first bit of information we need, i.e. the location within m_map in terms of element number.
     // Next we need to figure out which uint64 this is in.....
     unsigned int index = ref >> 6; // ....so divide by 64
     // get the value from this location to a temporary variable
     uint64 returnvalue = m_map[index];
     // identify the bits we are interested in
     uint64 bits = ( ref & 63 );
     // Our mask is sized based on the colours represented 1 - binary, 2 - 4, 4 - 16 , 8 - 256 (NB only powers of 2 are allowed).
     // The mask is created in the constructor.
     // So we need to shift our return value and mask it.
     returnvalue = ( returnvalue >> bits ) & m_mask;
     return returnvalue;
 }

References m_colourScaler, m_map, m_mask, m_resolutionscaler, and m_width.

Referenced by TrapLineMap::IsTrap().

◆ SetValue()

void BinaryMapBase::SetValue	(	unsigned	a_x,
		unsigned	a_y,
		unsigned	a_value
	)

 {
     // To find an x/y co-ordinate:
     // We need to find the 64-bit int that we are in, then the bit or bytes we need
     unsigned int ref = ( ( ( a_y >> m_resolutionscaler ) * m_width ) + ( a_x >> m_resolutionscaler ) ) * m_colourScaler;
     // ref holds the first bit of information we need, i.e. the location within m_map in terms of element number.
     // Next we need to figure out which uint64 this is in.....
     unsigned int index = ref >> 6; // ....so divide by 64
     // get the value from this location to a temporary variable
     uint64 newvalue = m_map[index];
     // identify the bits we are interested in
     uint64 bits = ( ref & 63 );
     // Our mask is sized based on the colours represented 1 - binary, 2 - 4, 4 - 16 , 8 - 256 (NB only powers of 2 are allowed).
     // The mask is created in the constructor.
     // So we need to shift our mask to cover the correct bits.
     uint64 mask = ~( m_mask << bits );
     // Blank out any current values
     newvalue = newvalue & mask;
     // Pop our new value in
     uint64 value = a_value;
     newvalue = newvalue | ( value  << bits);
     m_map[index] = newvalue;
 }