The landscape class containing all environmental and topographical data. More...

#include <landscape.h>

Public Member Functions
void	FillVegAreaData ()

double	GetVegArea (int v)

void	DumpVegAreaData (int a_day)

void	SkylarkEvaluation (SkTerritories *a_skt)

void	RodenticidePredatorsEvaluation (RodenticidePredators_Population_Manager *a_rppm)

Population_Manager *	SupplyThePopManager ()
	Get the pointer to the current main population manager. More...

void	SetThePopManager (Population_Manager *a_ptr)
	Set the pointer to the current main population manager. More...

int	SupplyFarmAnimalCensus (int a_farm_ref, int a_LifeStage)

int	SupplyVegPhase (int a_poly)

	~Landscape (void)

	Landscape (const char a_configfile, const char a_errorfile)

void	SimulationClosingActions ()

void	Tick (void)

void	TurnTheWorld (void)

int	HowManyPonds ()
	Returns the number of ponds in the landscape. More...

int	SupplyRandomPondIndex ()
	Returns random pond index. More...

int	SupplyRandomPondRef ()
	Returns random pond polyref. More...

int	SupplyPondIndex (int a_pondref)
	Returns the index of a pond based on pondref or -1 if not found. More...

void	SetMaleNewtPresent (int a_InPondIndex)
	Sets a male as being present in a pond. More...

bool	SupplyMaleNewtPresent (int a_InPondIndex)
	Determines if a male is present in a pond. More...

Farm *	SupplyFarmPtr (int a_owner)

FarmManager *	SupplyFarmManagerPtr ()

int	SupplyLargestPolyNumUsed ()

bool	SupplyShouldSpray ()

double	SupplyVegDigestabilityVector (unsigned int a_index)

double	SupplyVegDigestability (int a_polyref)

double	SupplyVegDigestability (int a_x, int a_y)

double	SupplyVegHeightVector (unsigned int a_index)

double	SupplyVegHeight (int a_polyref)

double	SupplyVegHeight (int a_x, int a_y)

double	SupplyVegBiomassVector (unsigned int a_index)

double	SupplyVegBiomass (int a_polyref)

double	SupplyVegBiomass (int a_x, int a_y)

int	SupplyVegDensity (int a_polyref)

int	SupplyVegDensity (int a_x, int a_y)

double	SupplyWeedBiomass (int a_polyref)

double	SupplyWeedBiomass (int a_x, int a_y)

bool	SupplySkScrapes (int a_polyref)

bool	SupplyVegPatchy (int a_polyref)

bool	SupplyVegPatchy (int a_x, int a_y)

double	SupplyGreenBiomass (int a_polyref)

double	SupplyGreenBiomass (int a_x, int a_y)

double	SupplyDeadBiomass (int a_polyref)

double	SupplyDeadBiomass (int a_x, int a_y)

double	SupplyLAGreen (int a_polyref)

double	SupplyLAGreen (int a_x, int a_y)

double	SupplyLATotal (int a_x, int a_y)

double	SupplyVegCover (int a_polyref)

double	SupplyVegCoverVector (unsigned int a_index)

double	SupplyVegCover (int a_x, int a_y)

TTypesOfVegetation	SupplyLastSownVeg (int a_polyref)

TTypesOfVegetation	SupplyLastSownVeg (int a_x, int a_y)

TTypesOfVegetation	SupplyLastSownVegVector (unsigned int a_index)

double	SupplyInsects (int a_polyref)

double	SupplyInsects (int a_x, int a_y)

bool	SubtractPondLarvalFood (double a_food, int a_polyrefindex)
	Removes larval food from a pond and returns true if it was possible, otherwise false. More...

double	SupplyRodenticide (int a_x, int a_y)
	Gets total rodenticide for a location. More...

bool	SupplyPesticideDecay ()
	Returns true if there is any pesticide in the system at all at this point. More...

double	SupplyPesticide (int a_x, int a_y)
	Gets total pesticide for a location. More...

bool	SupplyOverspray (int a_x, int a_y)
	Gets the overspray flag. More...

double	SupplyPesticideP (int a_x, int a_y)
	Gets plant pesticide for a location. More...

double	SupplyPesticideS (int a_x, int a_y)
	Gets soil pesticide for a location. More...

double	SupplyPesticide (int a_polyref)
	Gets total pesticide for the centroid of a polygon. More...

double	SupplyPesticideP (int a_polyref)
	Gets plant pesticide for the centroid of a polygon. More...

double	SupplyPesticideS (int a_polyref)
	Gets soil pesticide for the centroid of a polygon. More...

RodenticidePredators_Population_Manager *	SupplyRodenticidePredatoryManager ()

TTypesOfPesticide	SupplyPesticideType (void)

GooseFieldList *	GetGooseFields (double)
	Gets the list of suitable goose foraging fields today. More...

void	CalculateOpenness (bool a_realcalc)
	Causes openness to be calulated and stored for all polygons. More...

void	WriteOpenness (void)
	Stores openness for all polygons to a standard file. More...

void	ReadOpenness (void)
	Reads openness values from a standard input file for all polygons. More...

int	CalulateFieldOpennessCentroid (int a_pref)
	Provides a measure of the shortest distance in 360 degree, e-g- looking NE % SW before tall obstacles are encountered at both ends. Searches from centroid. More...

int	CalulateFieldOpennessAllCells (int a_pref)
	Provides a measure of the shortest distance in 360 degree, e-g- looking NE % SW before tall obstacles are encountered at both ends. Checks all field 1m2. More...

int	LineHighTest (int a_cx, int a_cy, double a_offsetx, double a_offsety)
	Provides a measure of the shortest distance in using a vector from a_cx,a_cy unitl tall obstacles are encountered in both +ve & -ve directions. More...

int	SupplyOpenness (int a_poly)
	Get openness for a polygon. More...

int	SupplyOpenness (int a_x, int a_y)
	Get openness for a location. More...

bool	SupplyLEHigh (int a_x, int a_y)
	Tests whether the polygon at a_x,a_y is designated as high. More...

polylist *	SupplyLargeOpenFieldsNearXY (int x, int y, int range, int a_openness)
	Returns a pointer to a list of polygonrefs to large open fields within a range of location x,y. More...

int	SupplySoilType (int a_x, int a_y)
	Returns the soil type in ALMaSS types reference numbers. More...

int	SupplySoilTypeR (int a_x, int a_y)
	Returns the soil type in rabbit warren reference numbers. More...

APoint	SupplyCentroid (int a_polyref)

APoint	SupplyCentroidIndex (int a_polyrefindex)

int	SupplyCentroidX (int a_polyref)

int	SupplyCentroidY (int a_polyref)

int	SupplyCentroidX (int a_x, int a_y)

int	SupplyCentroidY (int a_x, int a_y)

int	SupplyFarmIntensity (int a_x, int a_y)

int	SupplyFarmIntensity (int a_polyref)

int	SupplyFarmIntensityI (int a_polyindex)

TTypesOfLandscapeElement	SupplyElementType (int a_polyref)

TTypesOfLandscapeElement	SupplyElementType (int a_x, int a_y)

TTypesOfLandscapeElement	SupplyElementTypeCC (int a_x, int a_y)

int	SupplyCountryDesig (int a_x, int a_y)

int	SupplyElementSubType (int a_polyref)

int	SupplyElementSubType (int a_x, int a_y)

TTypesOfVegetation	SupplyVegType (int a_x, int a_y)

TTypesOfVegetation	SupplyVegType (int polyref)

TTypesOfVegetation	SupplyVegTypeVector (unsigned int a_index)

int	SupplyGrazingPressureVector (unsigned int a_index)

int	SupplyGrazingPressure (int a_polyref)

int	SupplyGrazingPressure (int a_x, int a_y)

bool	SupplyIsCereal (int a_polyref)

bool	SupplyIsMatureCereal (int a_polyref)

bool	SupplyIsGrass (int a_polyref)

bool	SupplyHasTramlines (int a_x, int a_y)

bool	SupplyHasTramlines (int a_polyref)

bool	SupplyJustMownVector (unsigned int a_index)

bool	SupplyJustMown (int a_polyref)

int	SupplyJustSprayedVector (unsigned int a_index)

int	SupplyJustSprayed (int a_polyref)

int	SupplyJustSprayed (int a_x, int a_y)

int	SupplyTreeAge (int a_Polyref)

int	SupplyTreeAge (int, int)

int	SupplyVegAge (int a_Polyref)

int	SupplyVegAge (int a_x, int a_y)

int	SupplyNumberOfFarms ()

int	SupplyFarmOwner (int a_x, int a_y)

int	SupplyFarmOwner (int a_polyref)

int	SupplyFarmOwnerIndex (int a_x, int a_y)

int	SupplyFarmOwnerIndex (int a_polyref)

TTypesOfFarm	SupplyFarmType (int a_polyref)

TTypesOfFarm	SupplyFarmType (int a_x, int a_y)

TTypesOfOptFarms	SupplyOptFarmType (int a_x, int a_y)

int	SupplyFarmArea (int a_polyref)

double	SupplyPolygonAreaVector (int a_polyref)
	Returns the area of a polygon using the vector index as a reference. More...

double	SupplyPolygonArea (int a_polyref)

void	SetBirdSeedForage (int a_polyref, double a_fooddensity)
	Sets the grain forage resource as seen from a goose standpoint at a polygon. More...

void	SetBirdMaizeForage (int a_polyref, double a_fooddensity)
	Sets the maize forage resource as seen from a goose standpoint at a polygon. More...

double	SupplyGooseGrazingForageH (double a_height, GooseSpecies a_goose)
	Returns the leaf forage resource as seen from a goose standpoint at a polygon based on the height only. More...

double	SupplyGooseGrazingForageH (int a_polygon, GooseSpecies a_goose)
	Returns the leaf forage resource as seen from a goose standpoint at a polygon referenced by number based on height only. More...

double	GetActualGooseGrazingForage (int a_x, int a_y, GooseSpecies a_goose)
	Returns the leaf forage resource as seen from a goose standpoint at a polygon referenced by x,y location. More...

double	GetActualGooseGrazingForage (int a_polygon, GooseSpecies a_goose)
	Returns the leaf forage resource as seen from a goose standpoint at a polygon referenced by x,y location The amount of food avaiable as grazing resource based on the vegetation height is species specific. More...

double	SupplyBirdSeedForage (int a_polyref)
	Returns the grain forage resource. More...

double	SupplyBirdSeedForage (int a_x, int a_y)
	Returns the grain forage resource as seen from a goose standpoint at an x,y location. More...

double	SupplyBirdMaizeForage (int a_polyref)
	Returns the maize forage resource. More...

double	SupplyBirdMaizeForage (int a_x, int a_y)
	Returns the maize forage resource as seen from a goose standpoint at an x,y location. More...

void	RecordGooseNumbers (int a_poly, int a_number)
	This records the number of geese on the polygon the day before. To prevent lots of unnecessary clearing of values two values are saved, the number and simulation day - on reading the simulation day number can be used to modify the return value - see GetGooseNumbers() More...

void	RecordGooseSpNumbers (int a_poly, int a_number, GooseSpecies a_goose)
	This records the number of geese of each species on the polygon the day before. To prevent lots of unnecessary clearing of values two values are saved, the number and simulation day - on reading the simulation day number can be used to modify the return value - see GetGooseNumbers() More...

void	RecordGooseNumbersTimed (int a_poly, int a_number)
	This records the number of geese on the polygon the day before at a predefined time. To prevent lots of unnecessary clearing of values two values are saved, the number and simulation day - on reading the simulation day number can be used to modify the return value - see GetGooseNumbers() More...

void	RecordGooseSpNumbersTimed (int a_poly, int a_number, GooseSpecies a_goose)
	This records the number of geese of each species on the polygon the day before at a predefined time. To prevent lots of unnecessary clearing of values two values are saved, the number and simulation day - on reading the simulation day number can be used to modify the return value - see GetGooseNumbers() More...

void	GrazeVegetation (int a_poly, double a_forage)
	Removes grazing forage from a poly per m2. More...

void	GrazeVegetationTotal (int a_poly, double a_forage)
	Removes grazing forage from a poly and divides this out per m2. More...

int	GetGooseNumbers (int a_poly)
	This returns the number of geese on the polygon the day before. More...

int	GetGooseNumbers (int a_x, int a_y)
	This returns the number of geese on the polygon specifed by a_x, a_y the day before. More...

int	SupplyLastTreatment (int a_polyref, int *a_index)

int	SupplyLastTreatment (int a_x, int a_y, int *a_index)

double	GetHareFoodQuality (int a_polygon)

double	SupplyGlobalRadiation ()

double	SupplyGlobalRadiation (long a_date)

double	SupplyRain (void)

double	SupplyTemp (void)

double	SupplyHumidity (void)

double	SupplyMeanTemp (long a_date, unsigned int a_period)

double	SupplyWind (void)

int	SupplyWindDirection (void)

double	SupplySnowDepth (void)

bool	SupplySnowcover (void)

int	SupplyDaylength (void)

double	SupplyRain (long a_date)

double	SupplyTemp (long a_date)

double	SupplyWind (long a_date)

double	SupplyDayDegrees (int a_polyref)

double	SupplyRainPeriod (long a_date, int a_period)

double	SupplyWindPeriod (long a_date, int a_period)

double	SupplyTempPeriod (long a_date, int a_period)

bool	SupplySnowcover (long a_date)

bool	IsFieldType (TTypesOfLandscapeElement a_tole)

int	SupplyPolyRef (int a_x, int a_y)

int	SupplyPolyRefIndex (int a_x, int a_y)

int	SupplyPolyRefCC (int a_x, int a_y)

int	SupplySimAreaWidth (void)

int	SupplySimAreaHeight (void)

int	SupplySimAreaMaxExtent (void)

int	SupplySimAreaMinExtent (void)

int	SupplyDaylength (long a_date)

int	SupplyDayInYear (void)

int	SupplyHour (void)
	Get the hour of the day. More...

int	SupplyMinute (void)
	Get the minute of the hour. More...

unsigned int	SupplyNumberOfPolygons (void)

TTypesOfLandscapeElement	SupplyElementTypeFromVector (unsigned int a_index)

int	SupplyPolyRefVector (unsigned int a_index)

int	SupplyPesticideCell (int a_polyref)

int	SupplyValidX (int a_polyref)

int	SupplyValidY (int a_polyref)

double	SupplyPondPesticide (int a_poly_index)
	Get the pesticide concentration per liter from a pond (must be a pond index on calling) More...

void	CorrectCoords (int &x, int &y)
	Function to prevent wrap around errors with co-ordinates using x/y pair. More...

APoint	CorrectCoordsPt (int x, int y)
	Function to prevent wrap around errors with co-ordinates using x/y pair. More...

void	CorrectCoordsPointNoWrap (APoint &a_pt)
	Function to prevent wrap around errors with co-ordinates using a APoint. More...

int	CorrectWidth (int x)

int	CorrectHeight (int y)

void	SetPolyMaxMinExtents (void)

void	CalculateCentroids (void)

void	DumpCentroids (void)

void	BuildingDesignationCalc ()
	used to calculate whether a building is rural or town - for rodenticide use More...

void	CentroidSpiralOut (int a_polyref, int &a_x, int &a_y)

void	CentroidSpiralOutBlocks (int a_polyref, int &a_x, int &a_y)

const char *	SupplyVersion (void)

void	DumpPublicSymbols (const char *a_dumpfile, CfgSecureLevel a_level)

void	DumpAllSymbolsAndExit (const char *a_dumpfile)

bool	ReadSymbols (const char *a_cfgfile)

void	DumpMapInfoByArea (const char *a_filename, bool a_append, bool a_dump_zero_areas, bool a_write_veg_names)

void	Warn (std::string a_msg1, std::string a_msg2)

int *	SupplyMagicMapP (int a_x, int a_y)

int	MagicMapP2PolyRef (int a_magic)

int	SupplyRoadWidth (int, int)

double	SupplyTrafficLoad (int a_x, int a_y)

double	SupplyTrafficLoad (int a_polyref)

int	SupplyTreeHeight (int, int)

int	SupplyUnderGrowthWidth (int, int)

int	SupplyTreeHeight (int)

int	SupplyUnderGrowthWidth (int)

long	SupplyGlobalDate (void)

int	SupplyYear (void)

int	SupplyYearNumber (void)

int	SupplyMonth (void)

int	SupplyDayInMonth (void)

double	SupplyDaylightProp ()

double	SupplyNightProp ()

void	SupplyLEReset (void)

int	SupplyLENext (void)

int	SupplyLECount (void)

LE_Signal	SupplyLESignal (int a_polyref)

void	SetLESignal (int a_polyref, LE_Signal a_signal)

void	IncTreatCounter (int a_treat)

TTypesOfLandscapeElement	TranslateEleTypes (int EleReference)

TTypesOfVegetation	TranslateVegTypes (int VegReference)

LE *	SupplyLEPointer (int a_polyref)

int	BackTranslateEleTypes (TTypesOfLandscapeElement EleReference)

int	BackTranslateVegTypes (TTypesOfVegetation VegReference)

std::string	EventtypeToString (int a_event)

std::string	PolytypeToString (TTypesOfLandscapeElement a_le_type)

std::string	VegtypeToString (TTypesOfVegetation a_veg)

Protected Member Functions
void	GISASCII_Output (string outpfile, int UTMX, int UTMY)
	Write ASCII file of the ALMaSS map. More...

void	AddGreenElement (LE *a_green)

void	ReadPolys (const char *a_polyfile)

void	ReadPolys2 (const char *a_polyfile)
	reads in polygon information. Version 2 including centroid and openness information More...

void	PolysValidate (bool a_exit_on_invalid)

void	PolysRemoveInvalid (void)

void	PolysDump (const char *a_filename)

void	DumpMap (const char *a_filename)

void	ConsolidatePolys (void)

void	CountMapSquares (void)

void	PolysRenumber (void)

void	RebuildPolyMapping ()

void	ForceArea (void)

void	ChangeMapMapping (void)

LE *	NewElement (TTypesOfLandscapeElement a_type)

void	RemoveMissingValues ()
	A method for replacing missing values in the map with corrected ones - slow. More...

void	TestCropManagement (void)

void	VegDump (int x, int y)

void	EventDump (int x, int y, int x2, int y2)

void	EventDumpPesticides (int x1, int y1)

void	DegreesDump ()
	Prints the sum of day degrees. See FarmManager::daydegrees. More...

bool	BorderNeed (TTypesOfLandscapeElement a_letype)

void	BorderAdd (LE *a_field, TTypesOfLandscapeElement a_type)

void	BorderRemoval (void)

int	RemoveSmallPolygons (void)
	Removes small polygons from the map. More...

void	CreatePondList ()
	Creates a list of pond polygon refs/indexes for easy look up. More...

void	UnsprayedMarginAdd (LE *a_field)

void	UnsprayedMarginScan (LE *a_field, int a_width)

void	BorderScan (LE *a_field, int a_width)

bool	BorderTest (int a_fieldpoly, int a_borderpoly, int a_x, int a_y)

bool	StepOneValid (int a_polyindex, int a_x, int a_y, int step)

bool	UMarginTest (int a_fieldpoly, int a_borderpoly, int a_x, int a_y, int a_width)

bool	FindValidXY (int a_field, int &a_x, int &a_y)

bool	BorderStep (int a_fieldpoly, int a_borderpoly, int a_x, int a_y)

bool	BorderStep (int a_fieldpoly, int a_borderpoly, APoint *a_coord)

void	AddBeetleBanks (TTypesOfLandscapeElement a_tole)

bool	BeetleBankPossible (LE *a_field, TTypesOfLandscapeElement a_tole)

void	BeetleBankAdd (int x, int y, int angle, int length, LE *a_field, TTypesOfLandscapeElement a_tole)

bool	FindFieldCenter (LE a_field, int x, int *y)

int	FindLongestAxis (int x, int y, int *a_length)

void	AxisLoop (int a_poly, int a_x, int a_y, int a_axis)

void	AxisLoop (int a_poly, APoint *a_cor, int a_axis)

void	AxisLoopLtd (int a_poly, APoint *a_cor, int a_axis, int a_limit)

void	hb_Add (void)

void	hb_AddNewHedgebanks (int a_orig_poly_num)

int	hb_StripingDist (void)

void	hb_GenerateHBPolys (void)

void	hb_FindHedges (void)

bool	hb_FindBoundingBox (int a_poly_num)

void	hb_UpPolyNumbers (void)

void	hb_ClearPolygon (int a_poly_num)

void	hb_PaintBorder (int a_color)

bool	hb_MapBorder (int a_x, int a_y)

bool	hb_HasOtherNeighbour (int a_x, int a_y)

bool	hb_PaintWhoHasNeighbourColor (int a_neighbour_color, int a_new_color)

bool	hb_HasNeighbourColor (int a_x, int a_y, int a_neighbour_color)

void	hb_MarkTopFromLocalMax (int a_color)

void	hb_MarkTheBresenhamWay (void)

int	hb_MaxUnpaintedNegNeighbour (int a_x, int a_y)

void	hb_ResetColorBits (void)

void	hb_RestoreHedgeCore (int a_orig_poly_number)

void	hb_DownPolyNumbers (void)

void	hb_Cleanup (void)

void	DumpMapGraphics (const char *a_filename)

void	DumpTreatCounters (const char *a_filename)

bool	CIPELandscapeMaker ()

void	MakeCluster (void)
	Reset all polygons natural grazing level to zero. More...

void	ReadInput (int , int , int , APoint )

APoint	RandomLocation (void)

APoint	GetNextSeed (int)

int	AddToClusterList (int , int , int , int , int *)

void	ModifyPolyRef (int *)

Protected Attributes
int	m_treatment_counts [last_treatment]

int	m_LargestPolyNumUsed

vector< int >	m_PondIndexList
	List of pond indexes. More...

vector< int >	m_PondRefsList
	List of pond polyrefs. More...

vector< int >	hb_hedges

vector< LE * >	hb_new_hbs

int	m_x_add [8]

int	m_y_add [8]

int *	hb_map

int	hb_width

int	hb_height

int	hb_size

int	hb_min_x

int	hb_max_x

int	hb_min_y

int	hb_max_y

int	hb_first_free_poly_num

int	hb_core_pixels

int	hb_border_pixels

TTypesOfPesticide	m_PesticideType
	An attribute to hold the pesticide type being tested, if there is one, if not default is -1. More...

bool	m_toxShouldSpray

int	le_signal_index

Private Attributes
char	m_versioninfo [30]

FarmManager *	m_FarmManager
	List of all the farms. More...

vector< LE * >	m_elems
	List of all landscape elements. The index is a sequential number, to get the polynum look this number up in m_polymapping. More...

RasterMap *	m_land
	The big map. More...

int	m_width

int	m_height

int	m_width10

int	m_height10

int	m_maxextent

bool	m_NeedCentroidCalculation
	a flag to ensure centroid calculation on object construction More...

bool	m_NeedOpennessCalculation
	a flag to ensure openness calculation on object construction More...

bool	m_DoMissingPolygonsManipulations

double *	l_vegtype_areas

Population_Manager *	m_ThePopManager
	a pointer to the current main population manager More...

RodenticideManager *	m_RodenticideManager

RodenticidePredators_Population_Manager *	m_RodenticidePreds

Polynomial2CurveClass *	m_GooseIntakeRateVSVegetationHeight_PF
	Curve relatning goose intake rates in KJ/min to vegetation height. More...

Polynomial2CurveClass *	m_GooseIntakeRateVSVegetationHeight_BG

Polynomial2CurveClass *	m_GooseIntakeRateVSVegetationHeight_GL

Detailed Description

The landscape class containing all environmental and topographical data.

Definition at line 109 of file landscape.h.

Constructor & Destructor Documentation

Landscape::~Landscape ( void )

Definition at line 1255 of file Landscape.cpp.

References cfg_rodenticide_enable, g_crops, g_date, g_letype, g_msg, g_pest, g_weather, l_map_dump_treatcounts_enable, l_map_dump_treatcounts_file, CfgBool::value(), and CfgStr::value().

                             {
   if ( l_map_dump_treatcounts_enable.value() ) {
     DumpTreatCounters( l_map_dump_treatcounts_file.value() );
   }
 
   for ( unsigned int i = 0; i < m_elems.size(); i++ )
     delete m_elems[ i ];
 
   free( m_polymapping );
   free( l_vegtype_areas );
   delete m_land;
   //delete g_rotation;
   delete g_crops;
   delete g_letype;
   delete g_weather;
   delete g_date;
   delete g_pest;
   if (cfg_rodenticide_enable.value())
   {
       delete m_RodenticideManager;
       delete m_RodenticidePreds;
   }
   delete m_FarmManager;
   delete g_msg; // Must be last.
 }

Landscape::Landscape	(	const char *	a_configfile,
		const char *	a_errorfile
	)

If the farmer decision making model is on, the FarmManager::InitFarms() is called here to initialise the farms. The FarmManager::FindNeighbours() function is called.

Next job after checking the basic map validity is to deal with any missing polygon information This is done by identifying the polygons that are large contiguous areas and making them wasteland. The rest are left and nibbled away to join adjacent polygons. This is a time consuming operation so is only done if there have been any missing info polygons found.

To be sure we have enough space to do map manipulations if required, then the polygons need to be renumbered - unless they are done already.

Rodenticide handling code. If enabled then rodenticide mapping provides access to predicted relative density of poisoned rodents per unit area.

Definition at line 677 of file Landscape.cpp.

References cfg_AddBeetleBanks, cfg_BeetleBankType, cfg_dumpvegjan, cfg_dumpvegjanfile, cfg_dumpvegjune, cfg_dumpvegjunefile, cfg_HedgeSubtypeMaximum, cfg_HedgeSubtypeMinimum, cfg_MaxPondSize, cfg_pesticidetesttype, cfg_rodenticide_enable, LE::DoCopy(), g_cfg, g_crops, g_date, g_letype, g_map_le_border_chance, g_map_le_borderremoval, g_map_le_borders, g_map_le_borders_min_field_size, g_map_le_borderstype, g_map_le_borderwidth, g_map_le_unsprayedmargins, g_map_orchards_borders, g_msg, g_pest, g_weather, l_map_art_hedgebanks, l_map_ascii_utm_x, l_map_ascii_utm_y, l_map_calc_openness, l_map_consolidatepolys, l_map_cropcurves_file, l_map_dump_enable, l_map_dump_event_enable, l_map_dump_gfx_enable, l_map_dump_gfx_file, l_map_dump_map_file, l_map_dump_poly_file, l_map_dump_veg_enable, l_map_map_file, l_map_no_pesticide_fields, l_map_poly_file, l_map_print_version_info, l_map_removesmallpolygons, l_map_weather_file, l_map_write_ascii, last_treatment, RasterMap::MapWidth(), Configurator::ReadSymbols(), Calendar::Reset(), LE::SetALMaSSEleType(), LE::SetArea(), LE::SetCentroid(), LE::SetElementType(), LE::SetOpenness(), LE::SetPoly(), LE::SetSoilType(), LE::SetUnsprayedMarginPolyRef(), MapErrorMsg::SetWarnLevel(), tole_Field, tole_Freshwater, tole_HedgeBank, tole_Hedges, tole_Missing, tole_Orchard, tole_Pond, tole_Wasteland, tov_Undefined, CfgInt::value(), CfgFloat::value(), CfgBool::value(), CfgStr::value(), MapErrorMsg::Warn(), WARN_ALL, WARN_BUG, and WARN_FILE.

                                                                         {
 
     // Set up operation flags
     bool didRenumber = false;
     bool didCalcCentroids = false;
     bool didConsolidate = false;
     bool didCalcOpenness = false;
     bool didCalcOther = false;
     m_NeedCentroidCalculation = false;
     m_NeedOpennessCalculation = false;
     m_DoMissingPolygonsManipulations = false;
     // Set up globals
     g_landscape_p = this;
     for (int i = 1; i <= 2000; i++) {
         g_SpeedyDivides[i] = 1 / double(i);
     }
     int x_add[8] = { 1, 1, 0, -1, -1, -1, 0, 1 }; // W,SW,S,SE,E,NE,N,NW
     int y_add[8] = { 0, -1, -1, -1, 0, 1, 1, 1 };
     for (int i = 0; i < 8; i++) {
         m_x_add[i] = x_add[i];
         m_y_add[i] = y_add[i];
     }
     //Pinkfeet
     m_GooseIntakeRateVSVegetationHeight_PF = new Polynomial2CurveClass(cfg_P1A.value(), cfg_P1B.value(), cfg_P1C.value(), cfg_P1D.value(), cfg_P1E.value(), cfg_P1F.value(), cfg_P1G.value(), cfg_P1H.value());
     //Barnacle
     m_GooseIntakeRateVSVegetationHeight_BG = new Polynomial2CurveClass(cfg_B6A.value(), cfg_B6B.value(), cfg_B6C.value(), cfg_B6D.value(), cfg_B6E.value(), cfg_B6F.value(), cfg_B6G.value(), cfg_B6H.value());
     //Greylag
     m_GooseIntakeRateVSVegetationHeight_GL = new Polynomial2CurveClass(cfg_G6A.value(), cfg_G6B.value(), cfg_G6C.value(), cfg_G6D.value(), cfg_G6E.value(), cfg_G6F.value(), cfg_G6G.value(), cfg_G6H.value());
     if (cfg_WriteCurve.value()) {
         m_GooseIntakeRateVSVegetationHeight_GL->WriteDataFile( 10 );
         m_GooseIntakeRateVSVegetationHeight_BG->WriteDataFile( 10 );
         m_GooseIntakeRateVSVegetationHeight_PF->WriteDataFile( 10 );
     }
     
     sprintf(m_versioninfo, "%d.%d.%d :: %s", version_major, version_minor, version_revision, version_date);
 
     if (l_map_print_version_info.value()) {
         printf("This program uses the Landscape simulator V%s\n", m_versioninfo);
     }
     //g_cfg->DumpAllSymbolsAndExit( "allsymbols.cfg" );
 
     // Must come first. Used by the configurator below.
     g_msg = new MapErrorMsg(a_errorfile);
     g_msg->SetWarnLevel(WARN_ALL);
 
     //g_cfg->DumpAllSymbolsAndExit( "allsymbols.cfg" );
 
     // Configurator instantiation is automatic.
     g_cfg->ReadSymbols(a_configfile);
     //g_cfg->DumpAllSymbolsAndExit( "allsymbols.cfg" );
 
     // For testing.
     //g_cfg->DumpPublicSymbols( "publicsymbols.cfg", CFG_PUBLIC );
     //exit(1);
 
     g_date = new Calendar;
     g_weather = new Weather(l_map_weather_file.value());
     g_letype = new LE_TypeClass;
     g_crops = new CropData(l_map_cropcurves_file.value());
 
     m_LargestPolyNumUsed = -1;
 
     // Reset treatment counters.
     for (int i = 0; i < last_treatment; i++) {
         m_treatment_counts[i] = 0;
     }
 
     m_FarmManager = new FarmManager();
 
 
     ReadPolys2(l_map_poly_file.value());
 
     //this carries out the optimisation
     if (cfg_OptimisingFarms.value()){
         m_FarmManager->InitFarms();
         m_FarmManager->Save_diff_farm_types_areas();
     }
 
 
     m_land = new RasterMap(l_map_map_file.value(), this);
     m_width = m_land->MapWidth();
     m_height = m_land->MapHeight();
     m_width10 = 10 * m_width;
     m_height10 = 10 * m_height;
     if (m_width > m_height) m_maxextent = m_width; else m_maxextent = m_height;
 
     PolysValidate(false);
 
     g_pest = new Pesticide(m_land, this);
     m_toxShouldSpray = false;
 
     // Validate polygons, ie. ensure those reference in the
     // polygon file also shows up in the map.
     PolysValidate(false);
     PolysRemoveInvalid();
 
     if (cfg_MaxPondSize.value() > 0) {
         // This takes any small freshwater and converts it to a pond.
         for (unsigned int i = 0; i < m_elems.size(); i++) {
             if (m_elems[i]->GetElementType() == tole_Freshwater) {
                 if (m_elems[i]->GetArea() <= cfg_MaxPondSize.value()) {
                     Pond* pond = new Pond;
                     pond->DoCopy(m_elems[i]);
                     pond->SetALMaSSEleType(g_letype->BackTranslateEleTypes(tole_Pond));
                     pond->SetElementType(tole_Pond);
                     m_elems[i] = dynamic_cast<LE*>(pond);
                 }
             }
         }
     }
 
     PolysValidate(true);
 
     if (m_DoMissingPolygonsManipulations)
     {
         // Find big continuous polygons
         for (unsigned int i = 0; i < m_elems.size(); i++)
         {
             if (m_elems[i]->GetElementType() == tole_Missing)
             {
                 double area = m_elems[i]->GetArea();
                 int areaMinrect = (m_elems[i]->GetMaxX() - m_elems[i]->GetMinX()) * (m_elems[i]->GetMaxY() - m_elems[i]->GetMinY());
                 if ((areaMinrect / area > 4) || (area < 1000))
                 {
                     // Unlikely to be a field, or if so a very narrow odd one. We will assume this is a missing data issue.
                 }
                 else
                 {
                     // Big poly with more than 25% of the included rectangle covered, must be a field of some sort.
                     // create a new wasteland and swap this in to the m_elems, then delete the old missing polygon
                     LE * wl = NewElement(tole_Wasteland);
                     wl->SetPoly(m_elems[i]->GetPoly());
                     wl->SetArea(floor(0.5 + area));
                     wl->SetSoilType(m_elems[i]->GetSoilType());
                     wl->SetUnsprayedMarginPolyRef(-1);
                     wl->SetCentroid(-1, -1);
                     wl->SetOpenness(0);
                     delete m_elems[i];
                     m_elems[i] = wl;
                 }
             }
         }
         // By here all the big ones should be safely tidied away to wasteland and now we need to deal with the raster map.
         RemoveMissingValues();
         for (unsigned int i = 0; i < m_elems.size(); i++)
         {
             // Now we deal with all the little ones that were not by fields
             if (m_elems[i]->GetElementType() == tole_Missing)
             {
                 LE * wl = NewElement(tole_Wasteland);
                 wl->SetPoly(m_elems[i]->GetPoly());
                 wl->SetArea(m_elems[i]->GetArea());
                 wl->SetSoilType(m_elems[i]->GetSoilType());
                 wl->SetUnsprayedMarginPolyRef(-1);
                 wl->SetCentroid(-1, -1);
                 wl->SetOpenness(0);
                 delete m_elems[i];
                 m_elems[i] = wl;
             }
         }
         PolysValidate(false);
         PolysRemoveInvalid();
         PolysValidate(true);
         g_msg->Warn("Landscape::Landscape(): Dump and normal exit to follow after resolving missing polygons. ", "");
         didCalcOther = true;
     }
 
     // ChangeMapMapping() also enters a valid starting
     // coordinate for the border generating farm method below.
     ChangeMapMapping();
 
     if ((m_LargestPolyNumUsed != ((int)m_elems.size() - 1)))
     {
         PolysRenumber();
         didRenumber = true;
     }
     // do we want to remove small polygons?
     if (l_map_removesmallpolygons.value())
     {
         cout << "In Landscape::Landscape() Small polygon removal" << endl;
         int removed = RemoveSmallPolygons();
         g_msg->Warn("Landscape::Landscape(): Dump and normal exit to follow after removing small polygons and map dump. Polygons removed:", removed);
         didCalcOther = true;
     }
     // Do we want to re-write the current files and consolidate polys?
     else if (l_map_consolidatepolys.value())
     {
         didConsolidate = true;
         ConsolidatePolys();
     }
     else if (g_map_le_borderremoval.value())
     {
         // Does not use centroids so is safe to use here
         BorderRemoval();
         CountMapSquares();
         ForceArea();
         g_msg->Warn(WARN_FILE, "Landscape::Landscape() - BorderRemoval "" map dump to follow.", "");
         didCalcOther = true;
     }
 
 
     // By the time we reach this point we need to have completed all major polygon removal and are ready to calculate centroids if they are needed. There
     // are two reasons for this - 1) that we did not have them in the original polyref file, 2) that we changed the map
     if (didConsolidate || didCalcOther || m_NeedCentroidCalculation)
     {
         PolysValidate(false);
         PolysRemoveInvalid();
         PolysValidate(true);
         ChangeMapMapping();
         PolysRenumber();
         CalculateCentroids();
         didCalcCentroids = true;
     }
     if (didConsolidate || didCalcOther || m_NeedCentroidCalculation || didCalcCentroids || l_map_calc_openness.value())
     {
         if (l_map_calc_openness.value()) CalculateOpenness(true);
         else CalculateOpenness(false);
         didCalcOpenness = true;
     }
     if (didCalcCentroids || didConsolidate || didCalcOpenness || didCalcOther || m_NeedCentroidCalculation || didRenumber || !m_FarmManager->GetIsRenumbered())
     {
         // We need to dump the map and polyrefs
         m_FarmManager->DumpFarmrefs();
         DumpMap(l_map_dump_map_file.value());
         PolysDump(l_map_dump_poly_file.value());
         g_msg->Warn(WARN_FILE, "Landscape::Landscape() ""Normal exit after dump.", "Remember to rename the new map and polyref file.");
         exit(0);
     }
 
     // Below here we have the more complicated map manipulations. These will need recalculation of centroids and openness after they are run.
     // However, we really do not want to get here with invalid centroids, hence forced dump and exit for manipulations up to this point.
 
     didCalcOther = false;
     // Add artificial hedgebanks to the hedges in the landscape,
     // if requested.
     if (l_map_art_hedgebanks.value()) {
         hb_Add();
         didCalcOther = true;
     }
     else if (g_map_le_borders.value())
     {
         cout << "Generating LE Borders around fields" << endl;
         cout << "Border chance = " << g_map_le_border_chance.value() << endl;
         cout << "Border width = " << g_map_le_borderwidth.value() << endl;
         // Generate border around each *farm* landscape element.
         cout << "Setting MaxMin Extents" << endl;
         SetPolyMaxMinExtents();
         cout << "Adding Borders" << endl;
         unsigned sz = (unsigned)m_elems.size();
         for (unsigned i = 0; i < sz; i++)
         {
             if (m_elems[i]->GetBorder() != NULL)
             {
                 // Border around this element, so must be a farm field.
                 // If the field is too small then ignore it
                 if (m_elems[i]->GetArea() > g_map_le_borders_min_field_size.value())
                 {
                     TTypesOfLandscapeElement  t = g_letype->TranslateEleTypes(g_map_le_borderstype.value());
                     BorderAdd(m_elems[i], t);
                 }
             }
         }
         didCalcOther = true;
     }
     else   // Some special code to 'soften' the edges of orchards
         if (g_map_orchards_borders.value())
         {
             // Generate border around each *farm* landscape element.
             for (unsigned int i = 0; i < m_elems.size(); i++) {
                 if (m_elems[i]->GetElementType() == tole_Orchard)
                 {
                     TTypesOfLandscapeElement  t = g_letype->TranslateEleTypes(g_map_le_borderstype.value());
                     BorderAdd(m_elems[i], t);
                 }
             }
             didCalcOther = true;
         }
         else
             // Unsprayed Margin Code....
             if (g_map_le_unsprayedmargins.value())
             {
                 CountMapSquares();
                 ForceArea();
 
                 // Generate border around each *farm* landscape element.
                 for (unsigned int i = 0; i < m_elems.size(); i++)
                 {
                     if (m_elems[i]->GetUnsprayedMarginPolyRef() != -1)
                     {
                         // But not if the field is too small to have them (<1Ha)
                         if (m_elems[i]->GetArea() > 10000)
                         {
                             // Border around this element, so must be a farm field.
                             UnsprayedMarginAdd(m_elems[i]);
                         }
                         else   m_elems[i]->SetUnsprayedMarginPolyRef(-1);
                     }
                 }
                 didCalcOther = true;
             }
             else if (cfg_AddBeetleBanks.value())
             {
                 cout << "Adding beetle banks now" << endl;
                 AddBeetleBanks((TTypesOfLandscapeElement)cfg_BeetleBankType.value());
                 didCalcOther = true;
             }
 
     if (l_map_dump_gfx_enable.value())
     {
         DumpMapGraphics(l_map_dump_gfx_file.value());
     }
 
     if (l_map_dump_enable.value() || didCalcOther)
     {
         CountMapSquares();
         ForceArea();
         PolysValidate(false);
         PolysRemoveInvalid();
         PolysValidate(true);
         ChangeMapMapping();
         PolysRenumber();
         CalculateCentroids();
         CalculateOpenness(l_map_calc_openness.value());
         m_FarmManager->DumpFarmrefs();
         cout << "Dumping map" << endl;
         DumpMap(l_map_dump_map_file.value());
         cout << "Dumping polygon refs file" << endl;
         PolysDump(l_map_dump_poly_file.value());
         g_msg->Warn(WARN_FILE, "Landscape::Landscape() ""Normal exit after dump.", "Remember to rename the new map and polyref file.");
         exit(0);
     }
 
     /*'''''''''''''''''' CIPE LANDSCAPE MAKER CODE HERE  //'''''''''''''''''''''
       if ( l_map_CIPEmaker_enable.value() ) {
       CIPELandscapeMaker();
       if ( l_map_dump_exit.value() ) {
       g_msg->Warn( WARN_FILE, "Landscape::Landscape(): ""Normal exit after map dump.", "" );
       exit( 0 );
       }
       }
       //'''''''''''''''''' CIPE LANDSCAPE MAKER CODE ABOVE //'''''''''''''''''''''
       */
     // Set the type of hedgebanks.
     int l_subtype = cfg_HedgeSubtypeMinimum.value();
     for (unsigned int i = 0; i < m_elems.size(); i++) {
         if (m_elems[i]->GetElementType() == tole_HedgeBank) {
             m_elems[i]->SetSubType(l_subtype);
             if (++l_subtype >= cfg_HedgeSubtypeMaximum.value())
                 l_subtype = cfg_HedgeSubtypeMinimum.value();
         }
     }
 
     // And another to set the type of hedges
     // ***CJT*** 2003-12-02
     l_subtype = 0;
     for (unsigned int i = 0; i < m_elems.size(); i++) {
         if (m_elems[i]->GetElementType() == tole_Hedges) {
             m_elems[i]->SetSubType(l_subtype);
             if (++l_subtype >= 3)
                 l_subtype = 0;
         }
     }
     // Count up the ponds and store them now we are finished with polygon handling.
     CreatePondList();
 
     cout << "Initiating farm management" << endl;
     m_FarmManager->InitiateManagement();
     g_date->Reset();
 
     /*
     if ( g_farm_test_crop.value() ) {
     TestCropManagement();
     exit( 0 );
     }
     */
 
     // Set up treatment flags
     // Reset internal state for the LE loop generator.
     // Compulsory!
     SupplyLEReset();
     // Get number of *all* landscape elements.
     int l_count = SupplyLECount();
 
     // Now loop through then.
     for (int i = 0; i < l_count; i++) {
         // Fetch next LE by its polygon reference number. Alternative
         // loop mechanism: This will return -1 at end-of-loop.
         int a_poly = SupplyLENext();
 
         // Skip uninteresting polygons by type, ownership,
         // phase of the moon, whatever.
         //    if ( these_are_not_the_droids_we_are_looking_for( a_poly )) {
         if (SupplyElementType(a_poly) != tole_Field)
             continue;
 
         // Example: Set x% of them to ignore insecticide of all types.
         if (random(100) < l_map_no_pesticide_fields.value()) {
             // Get current signal mask for polygon.
             LE_Signal l_signal = SupplyLESignal(a_poly);
             // Logical OR in/AND out the signals you are interested in.
             // The current signals are at the top of elements.h
             //l_signal |= LE_SIG_NO_INSECTICIDE | LE_SIG_NO_SYNG_INSECT | LE_SIG_NO_HERBICIDE | LE_SIG_NO_FUNGICIDE | LE_SIG_NO_GROWTH_REG;
             //l_signal |= LE_SIG_NO_INSECTICIDE | LE_SIG_NO_SYNG_INSECT | LE_SIG_NO_HERBICIDE;
             // Write the mask back out to the polygon.
             SetLESignal(a_poly, l_signal);
         }
     }
 
     l_vegtype_areas = (double *)malloc(sizeof(double) * (tov_Undefined + 1));
 
     if (l_vegtype_areas == NULL) {
         g_msg->Warn(WARN_BUG, "Landscape::Landscape(): Out of memory!", "");
         exit(1);
     }
     FILE * outf;
     if (cfg_dumpvegjan.value()) {
         outf = fopen(cfg_dumpvegjanfile.value(), "w");
         if (!outf) {
             g_msg->Warn(WARN_FILE, "Landscape::DumpMapInfoByArea(): ""Unable to create file", cfg_dumpvegjanfile.value());
             exit(1);
         }
         else
             fclose(outf);
     }
 
     if (cfg_dumpvegjune.value()) {
         outf = fopen(cfg_dumpvegjunefile.value(), "w");
         if (!outf) {
             g_msg->Warn(WARN_FILE, "Landscape::DumpMapInfoByArea(): ""Unable to create file", cfg_dumpvegjunefile.value());
             exit(1);
         }
         else
             fclose(outf);
     }
 
     // Dump veg information if necessary
     if (l_map_dump_veg_enable.value()) {
         FILE * f;
         f = fopen("VegDump.txt", "w");
         if (!f) {
             g_msg->Warn(WARN_BUG, "Landscape::Landscape(): VegDump.txt could not be created", "");
             exit(1);
         }
         fprintf(f, "Year\tDay\tHeight\tBiomass\tGrazed\tDensity\tCover\tWeedBiomass\ttovNum\tInsectBiomass\tLATotal\tLAGreen\tDigestability\tGreenBiomass\tDeadBiomass\tGooseGrazing\tSpilledGrain\nn");
         fclose(f);
     }
     if (l_map_dump_event_enable.value()) {
         FILE * f;
         f = fopen("EventDump.txt", "w");
         if (!f) {
             g_msg->Warn(WARN_BUG, "Landscape::Landscape(): EventDump.txt could not be created", "");
             exit(1);
         }
         fclose(f);
     }
 
     if (!cfg_OptimiseBedriftsmodelCrops.value()){
         m_FarmManager->FindNeighbours();
     }
 
     if (cfg_DumpFarmAreas.value()){
         m_FarmManager->DumpFarmAreas();
     }
 
     // If we are testing a pesticide then set the enum attribute
     m_PesticideType = (TTypesOfPesticide)cfg_pesticidetesttype.value();
 
     if (cfg_rodenticide_enable.value())
     {
         m_RodenticideManager = new RodenticideManager("BaitLocations_input.txt", this);
         m_RodenticidePreds = new RodenticidePredators_Population_Manager(this);
     }
 
     // Run a year to remove any start up effects
     cout << "Running intial start-up year" << endl;
     for (unsigned int i = 0; i < 365; i++)  Tick();
     //switch the rotation after running the hidden year (only for optimising farms), AM, 030713
     if (cfg_OptimisingFarms.value()) { m_FarmManager->Switch_rotation(); }
     // Write ASCII file:
     if (l_map_write_ascii.value()) {
         int x = l_map_ascii_utm_x.value();
         int y = l_map_ascii_utm_y.value();
         GISASCII_Output("AsciiLandscape.txt", x, y);
     }
 }

Member Function Documentation

void Landscape::AddBeetleBanks ( TTypesOfLandscapeElement a_tole )

protected

Beetle-bank addition - tests whether we can add a bank to this field, and then decides where to put it an adds it.

For each element, if it is a field then assess whether should have a beetle bank. This will depend on whether it is in the region defined for adding the bank, and a probability. This code requires polygon centroids to be active, either calculated or via l_map_read_openness == true.

To provide for more flexibilty, a tole_type is passed, and beetlebanks may be created of this tole_type instead of tole_BeetleBank

Definition at line 2504 of file Landscape.cpp.

References cfg_BeetleBankChance, cfg_BeetleBankInvert, cfg_BeetleBankMaxX, cfg_BeetleBankMaxY, cfg_BeetleBankMinX, cfg_BeetleBankMinY, g_msg, tole_Field, CfgInt::value(), CfgBool::value(), MapErrorMsg::Warn(), and WARN_MSG.

                                                                 {
     int BBs=0;
     int tx1 = cfg_BeetleBankMinX.value();
     int tx2 = cfg_BeetleBankMaxX.value();
     int ty1 = cfg_BeetleBankMinY.value();
     int ty2 = cfg_BeetleBankMaxY.value();
     bool doit = false;
     unsigned sz=(unsigned) m_elems.size();
     for (unsigned i=0; i<sz; i++)
     {
         if (m_elems[ i ]->GetElementType() == tole_Field)
         {
             doit = false;
             int cx = m_elems[ i ]->GetCentroidX();
             int cy = m_elems[ i ]->GetCentroidY();
             if (!cfg_BeetleBankInvert.value())
             {
                 if ((cx >= tx1) && (cy >= ty1) && (cx <= tx2) && (cy <= ty2))
                 {
                     doit = true;
                 }
             }
             else if ((cx < tx1) || (cy < ty1) || (cx > tx2) || (cy > ty2))
             {
                 doit = true;
             }
             if (doit)
             {
                 if (random(100)<cfg_BeetleBankChance.value())
                 {
                     if (BeetleBankPossible( m_elems[ i ], a_tole) ) BBs++;
                 }
             }
         }
     }
     char str[25];
     sprintf(str,"%d",BBs);
     g_msg->Warn( WARN_MSG, "Landscape::AddBeetleBanks(): BeetleBanks successfully added:", str );
 }

void Landscape::AddGreenElement ( LE * a_green )

protected

int Landscape::AddToClusterList	(	int *	,
		int *	,
		int *	,
		int *	,
		int *
	)

protected

void Landscape::AxisLoop	(	int	a_poly,
		int *	a_x,
		int *	a_y,
		int	a_axis
	)

protected

Starting at a_x,a_y each location is tested along a vector given by m_x_add & m_y_add until we step outside the polygon. a_x & a_y are modified on return.

Definition at line 2719 of file Landscape.cpp.

                                                                         {
     int ap1 = a_polyindex;
     while (ap1 == a_polyindex)
     {
         *(a_x) += m_x_add[a_axis];
         *(a_y) += m_y_add[a_axis];
         // Before we try to get a polyindex from the map, check we are still on the world
         if (*(a_x) < 0) 
         {
             return;
         }
         if (*(a_y) < 0)
         {
             return;
         }
         if (*(a_x) >= m_width) 
         {
             return;
         }
         if (*(a_y) >= m_height) 
         {
             return;
         }
         // OK still in the map, get the polyindex
         ap1 = m_land->Get((*a_x), (*a_y)); // NB this returns the m_elemens index not the polyref (ChangeMapMapping has been called by here)
     }
 }

void Landscape::AxisLoop	(	int	a_poly,
		APoint *	a_cor,
		int	a_axis
	)

protected

Starting at a_x,a_y each location is tested along a vector given by m_x_add & m_y_add until we step outside the polygon. a_x & a_y are modified on return.

Definition at line 2679 of file Landscape.cpp.

                                                                    {
     int ap1 = a_polyindex;
     while (ap1 == a_polyindex)
     {
         a_cor->m_x += m_x_add[a_axis];
         a_cor->m_y += m_y_add[a_axis];
         if (a_cor->m_x >= m_width - 1) { a_cor->m_x = m_width - 1; return; }
         if (a_cor->m_y >= m_height - 1) { a_cor->m_y = m_height - 1; return; }
         if (a_cor->m_x <= 0) { a_cor->m_x = 0; return; }
         if (a_cor->m_y <= 0) { a_cor->m_y = 0; return; }
         ap1 = m_land->Get(a_cor->m_x, a_cor->m_y); // NB this returns the m_elemens index not the polyref (ChangeMapMapping has been called by here)
     }
 }

void Landscape::AxisLoopLtd	(	int	a_poly,
		APoint *	a_cor,
		int	a_axis,
		int	a_limit
	)

protected

Starting at a_x,a_y each location is tested along a vector given by m_x_add & m_y_add until we step outside the polygon. a_x & a_y are modified on return.

Definition at line 2698 of file Landscape.cpp.

                                                                                    {
     int ap1 = a_polyindex;
     int count = 0;
     while (ap1 == a_polyindex && count<a_limit)
     {
         a_cor->m_x += m_x_add[a_axis];
         a_cor->m_y += m_y_add[a_axis];
         if (a_cor->m_x >= m_width - 1) { a_cor->m_x = m_width - 1; return; }
         if (a_cor->m_y >= m_height - 1) { a_cor->m_y = m_height - 1; return; }
         if (a_cor->m_x <= 0) { a_cor->m_x = 0; return; }
         if (a_cor->m_y <= 0) { a_cor->m_y = 0; return; }
         ap1 = m_land->Get(a_cor->m_x, a_cor->m_y); // NB this returns the m_elemens index not the polyref (ChangeMapMapping has been called by here)
         count++;
     }
 }

int Landscape::BackTranslateEleTypes ( TTypesOfLandscapeElement EleReference )

inline

Definition at line 1588 of file landscape.h.

References LE_TypeClass::BackTranslateEleTypes(), and g_letype.

 {
   return g_letype->BackTranslateEleTypes( EleReference );
 }

int Landscape::BackTranslateVegTypes ( TTypesOfVegetation VegReference )

inline

Definition at line 1595 of file landscape.h.

References LE_TypeClass::BackTranslateVegTypes(), and g_letype.

 {
   return g_letype->BackTranslateVegTypes( VegReference );
 }

void Landscape::BeetleBankAdd	(	int	x,
		int	y,
		int	angle,
		int	length,
		LE *	a_field,
		TTypesOfLandscapeElement	a_tole
	)

protected

Definition at line 2752 of file Landscape.cpp.

References LE::AddArea(), LE_TypeClass::BackTranslateEleTypes(), cfg_BeetleBankWidth, g_letype, LE::SetALMaSSEleType(), LE::SetArea(), LE::SetMapValid(), LE::SetPoly(), LE::SetValidXY(), LE::SetVegPatchy(), start, tole_BeetleBank, tole_MownGrass, tole_PermanentSetaside, and CfgInt::value().

                                                                                                                         {
     // Need to get a new number
     ++m_LargestPolyNumUsed;
     // Make the new landscape element
     LE * BeetleBank;
     switch (a_tole)
     {
     case tole_MownGrass:
         BeetleBank = NewElement( tole_MownGrass );
         BeetleBank->SetALMaSSEleType( g_letype->BackTranslateEleTypes( tole_MownGrass ) );
         break;
     case tole_PermanentSetaside:
         BeetleBank = NewElement( tole_PermanentSetaside );
         BeetleBank->SetALMaSSEleType( g_letype->BackTranslateEleTypes( tole_PermanentSetaside ) );
         break;
     case tole_BeetleBank:
     default:
         BeetleBank = NewElement( tole_BeetleBank );
         BeetleBank->SetALMaSSEleType( g_letype->BackTranslateEleTypes( tole_BeetleBank ) );
     }
     BeetleBank->SetVegPatchy(true);
     m_polymapping[ m_LargestPolyNumUsed ] =  (int) m_elems.size();
     m_elems.resize( m_elems.size() + 1 );
     m_elems[ m_elems.size() - 1 ] = BeetleBank;
     BeetleBank->SetPoly( m_LargestPolyNumUsed );
     // write lengthx12m to the map at alignment angle
     int area=0;
     int angle2=0;
     int width=cfg_BeetleBankWidth.value();
     if (a_angle==0) angle2=2;
     int start=(int)(a_length*0.1);
     for (int i=start; i<a_length; i++) {
         for (int w=0-width; w<width; w++) {
             int tx=w*m_x_add[angle2];
             int ty=w*m_y_add[angle2];
             m_land->Put( tx+a_x+i*m_x_add[a_angle], ty+a_y+i*m_y_add[a_angle], (int) m_elems.size() - 1 );
             m_land->Put( tx+a_x-i*m_x_add[a_angle], ty+a_y-i*m_y_add[a_angle], (int) m_elems.size() - 1 );
             area+=2;
             a_field->AddArea( -2.0 );
 
         }
     }
     BeetleBank->SetArea( double(area) );
     BeetleBank->SetValidXY( a_x+start*m_x_add[a_angle], a_y+start*m_y_add[a_angle] );
     BeetleBank->SetMapValid(true);
 
 }

bool Landscape::BeetleBankPossible	(	LE *	a_field,
		TTypesOfLandscapeElement	a_tole
	)

protected

Beetle bank placement rules are:
No bank if the total bank area is going to be >=5% of the field area
No bank if the field is < 1Ha
No bank if the breadth of the field is < 100m

Definition at line 2553 of file Landscape.cpp.

References cfg_BeetleBankMaxArea, cfg_BeetleBankWidth, LE::GetArea(), LE::GetCentroidX(), LE::GetCentroidY(), CfgInt::value(), and CfgFloat::value().

                                                                                   {
     int farea=(int)a_field->GetArea();
     if (farea<10000) return false;
     int cx=a_field->GetCentroidX();
     int cy=a_field->GetCentroidY();
     // The centroid is the only estimate we have (and it at least should be in the field).
     // So start here and find the centre
     if (!FindFieldCenter(a_field, &cx, &cy)) return false;
     // now get the alignment
     int length=0;
     int alignment=FindLongestAxis(&cx, &cy, &length);
     // reduce length by 20%
     length=int(length*0.8);
     int area=2*length*cfg_BeetleBankWidth.value(); // 12m wide fixed size
     if (area>(farea*cfg_BeetleBankMaxArea.value())) return false;
     // Must be small engough so lets draw it
     BeetleBankAdd(cx, cy, alignment, length , a_field, a_tole);
     return true;
 }

void Landscape::BorderAdd	(	LE *	a_field,
		TTypesOfLandscapeElement	a_type
	)

protected

Definition at line 2129 of file Landscape.cpp.

References g_map_le_borderwidth, g_msg, LE::GetValidX(), LE::GetValidY(), LE::SetArea(), LE::SetBorder(), LE::SetPoly(), CfgInt::value(), MapErrorMsg::Warn(), and WARN_BUG.

                                                                          {
     int x = a_field->GetValidX();
     int y = a_field->GetValidY();
   if ( ( x == -1 ) || ( y == -1 ) ) {
     g_msg->Warn( WARN_BUG, "Landscape::BorderAdd(): Uninitialized border coordinate!", "" );
     exit( 1 );
   }
   LE * border = NewElement(a_type);
   a_field->SetBorder( border );
   m_polymapping[ hb_first_free_poly_num ] = (int) m_elems.size();
   m_elems.resize( m_elems.size() + 1 );
   m_elems[ m_elems.size() - 1 ] = border;
   border->SetPoly( hb_first_free_poly_num++ );
   border->SetArea( 0.0 );
   BorderScan(a_field, g_map_le_borderwidth.value());
 }

bool Landscape::BorderNeed ( TTypesOfLandscapeElement a_letype )

protected

Definition at line 4147 of file Landscape.cpp.

References g_msg, tole_ActivePit, tole_AmenityGrass, tole_BareRock, tole_BeetleBank, tole_Building, tole_BuiltUpWithParkland, tole_Carpark, tole_Churchyard, tole_Coast, tole_ConiferousForest, tole_Copse, tole_DeciduousForest, tole_Field, tole_FieldBoundary, tole_FishFarm, tole_Freshwater, tole_Garden, tole_Heath, tole_HedgeBank, tole_Hedges, tole_HeritageSite, tole_IndividualTree, tole_LargeRoad, tole_Marsh, tole_MetalledPath, tole_MixedForest, tole_MownGrass, tole_NaturalGrassDry, tole_NaturalGrassWet, tole_Orchard, tole_OrchardBand, tole_Parkland, tole_PermanentSetaside, tole_PermPasture, tole_PermPastureLowYield, tole_PermPastureTussocky, tole_PitDisused, tole_PlantNursery, tole_Pond, tole_Pylon, tole_Railway, tole_River, tole_RiversidePlants, tole_RiversideTrees, tole_RoadsideSlope, tole_RoadsideVerge, tole_Saltmarsh, tole_Saltwater, tole_SandDune, tole_Scrub, tole_SmallRoad, tole_StoneWall, tole_Stream, tole_Track, tole_UnsprayedFieldMargin, tole_UrbanNoVeg, tole_UrbanPark, tole_Vildtager, tole_WindTurbine, tole_WoodlandMargin, tole_WoodyEnergyCrop, tole_YoungForest, MapErrorMsg::Warn(), and WARN_BUG.

                                                             {
     static char error_num[20];
     bool AddBorder = false;
     switch (a_letype) {
         // No border is needed toward these neighbouring element types.
     case tole_Hedges:
     case tole_HedgeBank:
     case tole_BeetleBank:
     case tole_RoadsideVerge:
     case tole_Marsh:
     case tole_RiversidePlants:
     case tole_UnsprayedFieldMargin:
     case tole_OrchardBand:
     case tole_MownGrass:
         break;
 
     case tole_IndividualTree:
     case tole_PlantNursery:
     case tole_Vildtager:
     case tole_WindTurbine:
     case tole_WoodyEnergyCrop:
     case tole_WoodlandMargin:
     case tole_Pylon:
     case tole_NaturalGrassDry:
     case tole_Railway:
     case tole_FieldBoundary:
     case tole_Scrub:
     case tole_Field:
     case tole_PermanentSetaside:
     case tole_PermPasture:
     case tole_PermPastureTussocky:
     case tole_PermPastureLowYield:
     case tole_PitDisused:
     case tole_RiversideTrees:
     case tole_DeciduousForest:
     case tole_MixedForest:
     case tole_YoungForest:
     case tole_ConiferousForest:
     case tole_StoneWall:
     case tole_Garden:
     case tole_Track:
     case tole_SmallRoad:
     case tole_LargeRoad:
     case tole_Building:
     case tole_ActivePit:
     case tole_Pond:
     case tole_FishFarm:
     case tole_Freshwater:
     case tole_River:
     case tole_Saltwater:
     case tole_Coast:
     case tole_BareRock:
     case tole_Heath:
     case tole_Orchard:
     case tole_AmenityGrass:
     case tole_Parkland:
     case tole_UrbanNoVeg:
     case tole_UrbanPark:
     case tole_BuiltUpWithParkland:
     case tole_SandDune:
     case tole_Copse:
     case tole_NaturalGrassWet:
     case tole_RoadsideSlope:
     case tole_MetalledPath:
     case tole_Carpark:
     case tole_Churchyard:
     case tole_Saltmarsh:
     case tole_Stream:
     case tole_HeritageSite:
         AddBorder = true;
         break;
 
     default:
         sprintf(error_num, "%d", a_letype);
         g_msg->Warn(WARN_BUG, "Landscape::BorderNeed(): Unknown element type:", error_num);
         exit(1);
     }
     return AddBorder;
 }

void Landscape::BorderRemoval ( void )

protected

Definition at line 2053 of file Landscape.cpp.

References tole_Field, tole_FieldBoundary, tole_HedgeBank, and tole_Hedges.

                               {
     // This does not need to be efficient, just do the job
     for (int x=1; x<(m_width-1); x++)
         for (int y=1; y<(m_height-1); y++)
         {
             TTypesOfLandscapeElement tole = SupplyElementType(x,y);
             if ((tole==tole_FieldBoundary) || (tole==tole_HedgeBank) || (tole==tole_Hedges))
             {
                 if ( SupplyElementType(x-1,y-1) == tole_Field)
                 {
                     // Set the x,y location to be this field
                     int fieldindex = SupplyPolyRefIndex(x-1,y-1);
                     m_land->Put( x, y, fieldindex );
 
                 }
                 else
                 if ( SupplyElementType(x-1,y) == tole_Field)
                 {
                     // Set the x,y location to be this field
                     int fieldindex = SupplyPolyRefIndex(x-1,y);
                     m_land->Put( x, y, fieldindex );
 
                 }
                 else
                 if ( SupplyElementType(x-1,y+1) == tole_Field)
                 {
                     // Set the x,y location to be this field
                     int fieldindex = SupplyPolyRefIndex(x-1,y+1);
                     m_land->Put( x, y, fieldindex );
 
                 }
                 else
                 if ( SupplyElementType(x,y-1) == tole_Field)
                 {
                     // Set the x,y location to be this field
                     int fieldindex = SupplyPolyRefIndex(x,y-1);
                     m_land->Put( x, y, fieldindex );
 
                 }
                 else
                 if ( SupplyElementType(x,y+1) == tole_Field)
                 {
                     // Set the x,y location to be this field
                     int fieldindex = SupplyPolyRefIndex(x,y+1);
                     m_land->Put( x, y, fieldindex );
 
                 }
                 else
                 if ( SupplyElementType(x+1,y-1) == tole_Field)
                 {
                     // Set the x,y location to be this field
                     int fieldindex = SupplyPolyRefIndex(x+1,y-1);
                     m_land->Put( x, y, fieldindex );
 
                 }
                 else
                 if ( SupplyElementType(x+1,y) == tole_Field)
                 {
                     // Set the x,y location to be this field
                     int fieldindex = SupplyPolyRefIndex(x+1,y);
                     m_land->Put( x, y, fieldindex );
 
                 }
                 else
                 if ( SupplyElementType(x+1,y+1) == tole_Field)
                 {
                     // Set the x,y location to be this field
                     int fieldindex = SupplyPolyRefIndex(x+1,y+1);
                     m_land->Put( x, y, fieldindex );
 
                 }
             }
         }
 }

void Landscape::BorderScan	(	LE *	a_field,
		int	a_width
	)

protected

Requires centroid calculation before calling this method. Centroids must be inside the polygon and valid.

Loop through this procedure the width of the margin times. Each time a dummy margin is added using polyref=-99 and all locations this is done are remembered. Then later all positions covered by -99 are replaced with the real polygon index.

Definition at line 2147 of file Landscape.cpp.

References LE::AddArea(), g_msg, LE::GetArea(), LE::GetBorder(), LE::GetCentroidX(), LE::GetCentroidY(), LE::GetPoly(), l_map_exit_on_zero_area, LE::SetMapValid(), CfgBool::value(), MapErrorMsg::Warn(), and WARN_FILE.

 {
     LE * border = a_field->GetBorder(); // border is the a border object
     int fieldpoly = a_field->GetPoly(); // fieldpoly is the polygon number
     int borderpoly = border->GetPoly(); // borderpoly is the polygon number
     int borderindex = m_polymapping[ borderpoly ]; // borderindex is the elems index for the border
     int fieldindex = m_polymapping[ fieldpoly ]; // fieldindex is the elems index
     int test = m_land->Get(a_field->GetCentroidX(), a_field->GetCentroidY());
     if (test != fieldindex)
     {
         g_msg->Warn("Landscape::BorderScan - Border Scan centroid does not return correct polygon index. Index :", fieldindex); 
         g_msg->Warn(" Returned ", test);
         exit(0);
     }
     int notforever = 50000;
     vector<APoint> listoflocs;
     for (int wid = 0; wid < a_width; wid++)
     {
         notforever = 50000;
         // These two will be modified through pointer operations in BorderStep().
         APoint coord(a_field->GetCentroidX(), a_field->GetCentroidY());
         // Find the first edge cell
         AxisLoop(fieldindex, &coord, random(8));
         while (--notforever > 0)
         {
             // Check if this position should be made into a border.
             if (BorderTest(fieldindex, -99, coord.m_x, coord.m_y))
             {
                 // Add this pixel to the border element in the big map, but using a code for later replacement.
                 m_land->Put(coord.m_x, coord.m_y, -99); // this puts the elems index into our map in memory
                 listoflocs.push_back(coord);
                 a_field->AddArea(-1.0);
                 if (l_map_exit_on_zero_area.value() && (a_field->GetArea()<1))
                 {
                     char polynum[20];
                     sprintf(polynum, "%d", a_field->GetPoly()); g_msg->Warn(WARN_FILE, "Landscape::BorderScan(): Polygon reached zero area " "when adding border. Poly num: ", polynum);
                     exit(1);
                 }
                 border->AddArea(1.0);
                 border->SetMapValid(true);
             }
             // Step to next coordinate. Quit when done.
             if (!BorderStep(fieldindex, -99, &coord))
             {
                 break;
             }
         }
         for (std::vector<APoint>::iterator it = listoflocs.begin(); it != listoflocs.end(); ++it)
         {
             m_land->Put((*it).m_x, (*it).m_y, borderindex);
         }
         listoflocs.clear();
     }
 }

bool Landscape::BorderStep	(	int	a_fieldpoly,
		int	a_borderpoly,
		int *	a_x,
		int *	a_y
	)

protected

Definition at line 2260 of file Landscape.cpp.

                                                                         {
     int index;
     int x_add[8] = { 1, 1, 0, -1, -1, -1, 0, 1 };
     int y_add[8] = { 0, -1, -1, -1, 0, 1, 1, 1 };
     int width = m_land->MapWidth();
     int height = m_land->MapHeight();
     int i = 7, counter = 8;
     bool running = true;
     // First scan for another pixel that belongs to this field.
     while (running)
     {
         if (!((*a_x) + x_add[i] >= width) && !((*a_x) + x_add[i] < 0) && !((*a_y) + y_add[i] >= height) && !((*a_y) + y_add[i] < 0))
         {
             index = m_land->Get((*a_x) + x_add[i], (*a_y) + y_add[i]);
             if (index == a_fieldindex)
             {
                 // Found the first field pixel while scanning around always
                 // in the same direction.
                 running = false;
             }
         }
         if (--i < 0) {
             // Didn't find any of our pixels. We are in a blind alley. Exit
             // gracefully.
             return false; // Signal done scanning this field.
         }
     }
 
     // Now scan around from our present facing direction and find the border
     // (if any).
     while (--counter)
     {
         if (!((*a_x) + x_add[i] >= width) && !((*a_x) + x_add[i] < 0) && !((*a_y) + y_add[i] >= height) && !((*a_y) + y_add[i] < 0))
         {
             index = m_land->Get((*a_x) + x_add[i], (*a_y) + y_add[i]);
             if (index == a_fieldindex)
             {
                 if (--i < 0) i = 7;
                 continue;
             }
         }
 
         // Aha! This pixel is not ours. Step one step in the
         // opposite(!) direction. If that pixel is ours, then
         // modify hotspot coordinates and exit.
         if (++i > 7) i = 0;
         if (!((*a_x) + x_add[i] + 1 > width) && !((*a_x) + x_add[i] < 0) && !((*a_y) + y_add[i] + 1 > height) &&
             !((*a_y) + y_add[i] < 0) && (m_land->Get((*a_x) + x_add[i], (*a_y) + y_add[i]) == a_fieldindex))
         {
             (*a_x) += x_add[i];
             (*a_y) += y_add[i];
             return true;
         }
     }
     return false;
 }

bool Landscape::BorderStep	(	int	a_fieldpoly,
		int	a_borderpoly,
		APoint *	a_coord
	)

protected

Definition at line 2318 of file Landscape.cpp.

                                                                    {
     int index;
     int x_add[8] = { 1, 1, 0, -1, -1, -1, 0, 1 };
     int y_add[8] = { 0, -1, -1, -1, 0, 1, 1, 1 };
     int width = m_land->MapWidth();
     int height = m_land->MapHeight();
     int i = 7, counter = 8;
     bool running = true;
     // First scan for another pixel that belongs to this field.
     while (running)
     {
         if (!((a_coord->m_x) + x_add[i] >= width) && !((a_coord->m_x) + x_add[i] < 0) && !((a_coord->m_y) + y_add[i] >= height) && !((a_coord->m_y) + y_add[i] < 0))
         {
             index = m_land->Get((a_coord->m_x) + x_add[i], (a_coord->m_y) + y_add[i]);
             if (index == a_fieldindex)
             {
                 // Found the first field pixel while scanning around always
                 // in the same direction.
                 running = false;
             }
         }
         if (--i < 0) {
             // Didn't find any of our pixels. We are in a blind alley. Exit
             // gracefully.
             return false; // Signal done scanning this field.
         }
     }
 
     // Now scan around from our present facing direction and find the border
     // (if any).
     while (--counter)
     {
         if (!((a_coord->m_x) + x_add[i] >= width) && !((a_coord->m_x) + x_add[i] < 0) && !((a_coord->m_y) + y_add[i] >= height) && !((a_coord->m_y) + y_add[i] < 0))
         {
             index = m_land->Get((a_coord->m_x) + x_add[i], (a_coord->m_y) + y_add[i]);
             if (index == a_fieldindex)
             {
                 if (--i < 0) i = 7;
                 continue;
             }
         }
 
         // Aha! This pixel is not ours. Step one step in the
         // opposite(!) direction. If that pixel is ours, then
         // modify hotspot coordinates and exit.
         if (++i > 7) i = 0;
         if (!((a_coord->m_x) + x_add[i] + 1 > width) && !((a_coord->m_x) + x_add[i] < 0) && !((a_coord->m_y) + y_add[i] + 1 > height) &&
             !((a_coord->m_y) + y_add[i] < 0) && (m_land->Get((a_coord->m_x) + x_add[i], (a_coord->m_y) + y_add[i]) == a_fieldindex))
         {
             (a_coord->m_x) += x_add[i];
             (a_coord->m_y) += y_add[i];
             return true;
         }
     }
     return false;
 }

bool Landscape::BorderTest	(	int	a_fieldpoly,
		int	a_borderpoly,
		int	a_x,
		int	a_y
	)

protected

Definition at line 2233 of file Landscape.cpp.

 {
   int index;
   int x_add[ 8 ] = { 1, 1, 0, -1, -1, -1, 0, 1 };
   int y_add[ 8 ] = { 0, -1, -1, -1, 0, 1, 1, 1 };
   int width = m_land->MapWidth();
   int height = m_land->MapHeight();
   // Scan anti-clockwise from center pixel coordinate.
   for ( unsigned int i = 0; i < 8; i++ ) {
     if ( ( a_x + x_add[ i ] >= width ) || ( a_x + x_add[ i ] < 0 ) || ( a_y + y_add[ i ] >= height )
          || ( a_y + y_add[ i ] < 0 ) ) {
            return true;
     }
     //continue;
     index = m_land->Get( a_x + x_add[ i ], a_y + y_add[ i ] );
     if ( ( index != a_fieldindex ) && ( index != a_borderindex ) )
     {
         return true;
         // Test removed 1/07/2014 CJT
       //if ( BorderNeed( m_elems[ index ]->GetElementType() ) ) return true;
       //else return false;
     }
   }
   return false;
 }

void Landscape::BuildingDesignationCalc ( )

used to calculate whether a building is rural or town - for rodenticide use

Runs through all elements and identifies the ones where rodenticide bait may be placed. If it is a building then we count the number of buildings near to it and designate it town if there are more than cfg_mintownbuildingnumber.

Definition at line 3066 of file Landscape.cpp.

References cfg_mintownbuildingdistance, cfg_mintownbuildingnumber, tole_Building, tole_ConiferousForest, tole_DeciduousForest, tole_MixedForest, tole_YoungForest, and CfgInt::value().

 {
     for (int p = 0; p< (int)m_elems.size(); p++)
     {
         TTypesOfLandscapeElement tole = m_elems[p]->GetElementType();
         if ( tole == tole_Building)
         {
             int cx = m_elems[p]->GetCentroidX();
             int cy = m_elems[p]->GetCentroidY();
             int near = 0;
             for (int j = 0; j< (int)m_elems.size(); j++)
             {
                 if (m_elems[j]->GetElementType() == tole_Building)
                 {
                     int nx = m_elems[j]->GetCentroidX();
                     int ny = m_elems[j]->GetCentroidY();
                     int dx =abs(cx-nx);
                     int dy =abs(cy-ny);
                     if ((dx < cfg_mintownbuildingdistance.value()) && (dy < cfg_mintownbuildingdistance.value())) near++;
                     if (near > cfg_mintownbuildingdistance.value()) break;
                 }
             }
             if (near <= cfg_mintownbuildingnumber.value()) m_elems[p]->SetCountryDesignation(1); // Not enough buildings close by, so it is a country building
             else m_elems[p]->SetCountryDesignation(0);
         }
         else if (tole == tole_YoungForest) 
         {
             m_elems[p]->SetCountryDesignation(2);
         }
         else if ((tole == tole_DeciduousForest) || ( tole == tole_MixedForest) || ( tole == tole_ConiferousForest ) ) m_elems[p]->SetCountryDesignation(3);
             
     }
 }

void Landscape::CalculateCentroids ( void )

Finds a location inside each polygon as a roughly calculated centre point. The point will be within the polygon. This also uses the stored Max/Min coordinates for each polygon that form a rectangle around it.

Definition at line 2821 of file Landscape.cpp.

 {
     cout << "In Centroid Calculations" << endl;
     // For each polygon
     for (int p = 0; p< (int)m_elems.size(); p++)
     {
         // Calcuate the actual centre
         int x1 = m_elems[p]->GetMinX();
         int y1 = m_elems[p]->GetMinY();
         int x2 = m_elems[p]->GetMaxX();
         int y2 = m_elems[p]->GetMaxY();
         int midx = (x1 + x2) / 2;
         int midy = (y1 + y2) / 2;
         // Now from midx & midy we move outwards in concentric circles until we find a location that matches our polyref.
         int polyindex = p; // Change mapmapping has been called by now, so the map contains m_elems indices.
         CentroidSpiralOut(polyindex, midx, midy);
         // Now we want to be sure that we are in the middle of the polygon not on the edge. This is tricky for complex shaped polygons, 
         // but we have a stab at it by using the FindLongestAxis method. This puts us in the centre of the longest axis in 8 directions
         // from this point
         int l;
         FindLongestAxis(&midx, &midy, &l);
         m_elems[p]->SetCentroid(midx, midy);
     }
     BuildingDesignationCalc();
 }

void Landscape::CalculateOpenness ( bool a_realcalc )

Causes openness to be calulated and stored for all polygons.

First must calculate centroid. Runs through the list of elements and any that are marsh, field, or pasture will have an openness score calculated

Definition at line 302 of file Landscape.cpp.

References tole_Field, tole_Marsh, tole_NaturalGrassDry, tole_NaturalGrassWet, tole_PermanentSetaside, tole_PermPasture, tole_PermPastureLowYield, tole_PermPastureTussocky, and tole_Scrub.

 {
     for (unsigned int i = 0; i < m_elems.size(); i++)
     {
         TTypesOfLandscapeElement tole = m_elems[i]->GetElementType();
         switch (tole)
         {
         case tole_Field:
         case tole_Marsh:
         case tole_Scrub:
         case tole_PermPastureLowYield:
         case tole_PermPastureTussocky:
         case tole_PermanentSetaside:
         case tole_PermPasture:
         case tole_NaturalGrassDry:
         case tole_NaturalGrassWet:
             if (a_realcalc)
             {
                 cout << i << " ";
                 m_elems[i]->SetOpenness(CalulateFieldOpennessAllCells(i));
             }
             else m_elems[i]->SetOpenness(0);
             break;
         default:
             m_elems[i]->SetOpenness(0);
             break;
         }
     }
     if (a_realcalc) cout << endl;
 }

int Landscape::CalulateFieldOpennessAllCells ( int a_pref )

Provides a measure of the shortest distance in 360 degree, e-g- looking NE % SW before tall obstacles are encountered at both ends. Checks all field 1m2.

Starts with North West and moves round the points of the compass 180 degrees. For each point tested we want the minimum length found, but between points we are interested in the max

runs a line out and also in 180 degrees, two lines.

Definition at line 379 of file Landscape.cpp.

 {
     int dline;
     int d0 = 0;
     int minX = m_elems[a_pref]->GetMinX();
     int minY = m_elems[a_pref]->GetMinY();
     int maxX = m_elems[a_pref]->GetMaxX();
     int maxY = m_elems[a_pref]->GetMaxY();
     for (int ax = minX; ax <= maxX; ax+=10)
     {
         for (int ay = minY; ay <= maxY; ay+=10)
         {
             dline = m_maxextent; // this is the width of the landscape and will always be at least as big as the biggest return value possible
             // Get a possible point for this field
             int cx = ax;
             int cy = ay;
             if (m_land->Get(ax, ay) == a_pref)
             {
                 double offsetx = -1;
                 double offsety = -1;
                 double dx = 1.0 / 45.0;
                 double dy = 0.0;
                 for (int deg = 0; deg<90; deg++)
                 {
                     int d1 = LineHighTest(cx, cy, offsetx, offsety);
                     int d2 = LineHighTest(cx, cy, 0 - offsetx, 0 - offsety);
                     int d = d1;
                     if (d1 > d2) d = d2;
                     if (dline > d) dline = d; // get the minimum
                     offsetx = offsetx + dx;
                     offsety = offsety + dy;
                 }
                 offsetx = 1;
                 offsety = 1;
                 dy = 0 - dx;
                 dx = 0;
                 for (int deg = 0; deg<90; deg++)
                 {
                     int d1 = LineHighTest(cx, cy, offsetx, offsety);
                     int d2 = LineHighTest(cx, cy, 0 - offsetx, 0 - offsety);
                     int d = d1;
                     if (d1 > d2) d = d2;
                     if (dline > d) dline = d;
                     offsetx = offsetx + dx;
                     offsety = offsety + dy;
                 }
                 if (dline > d0) d0 = dline; // Get the maximum. Here we might also want to do something like create statistics from the range of dline
             }
         }
     }
     return d0;
 }

int Landscape::CalulateFieldOpennessCentroid ( int a_pref )

Provides a measure of the shortest distance in 360 degree, e-g- looking NE % SW before tall obstacles are encountered at both ends. Searches from centroid.

Starts with North West and moves round the points of the compass 180 degrees.

runs a line out and also in 180 degrees, two lines.

Definition at line 337 of file Landscape.cpp.

 {
     // Get the centre point for this field
     int d0 = m_maxextent; // this is the width of the landscape and will always be at least as big as the biggest return value possible
     int cx = m_elems[a_pref]->GetCentroidX();
     int cy = m_elems[a_pref]->GetCentroidY();
 
     double offsetx = -1;
     double offsety = -1;
     double dx = 1.0 / 45.0;
     double dy = 0.0;
     for (int deg = 0; deg<90; deg++)
     {
         int d1 = LineHighTest(cx, cy, offsetx, offsety);
         int d2 = LineHighTest(cx, cy, 0 - offsetx, 0 - offsety);
         int d = d1;
         if (d1 > d2) d = d2;
         if (d0 > d) d0 = d;
         offsetx = offsetx + dx;
         offsety = offsety + dy;
     }
     offsetx = 1;
     offsety = 1;
     dy = 0 - dx;
     dx = 0;
     for (int deg = 0; deg<90; deg++)
     {
         int d1 = LineHighTest(cx, cy, offsetx, offsety);
         int d2 = LineHighTest(cx, cy, 0 - offsetx, 0 - offsety);
         int d = d1;
         if (d1 > d2) d = d2;
         if (d0 > d) d0 = d;
         offsetx = offsetx + dx;
         offsety = offsety + dy;
     }
     return d0;
 }

void Landscape::CentroidSpiralOut	(	int	a_polyref,
		int &	a_x,
		int &	a_y
	)

Definition at line 2853 of file Landscape.cpp.

References g_msg, and MapErrorMsg::Warn().

 {
     if (SupplyPolyRefIndex(a_x, a_y) == a_polyref) return; // Found it so return
     // Otherwise its not found so we need to start to spiral out
     int loop = 1;
     int sx = a_x;
     int sy = a_y;
     do {
         a_y = sy - loop;
         for (int i = 0 - loop; i <= loop; i++)
         {
             a_x = sx + i;
             CorrectCoords(a_x, a_y);
             if (SupplyPolyRefIndex(a_x, a_y) == a_polyref)
                 return; // Found it so return
         }
         a_y = sy + loop;
         for (int i = 0 - loop; i <= loop; i++)
         {
             a_x = sx + i;
             CorrectCoords(a_x, a_y);
             if (SupplyPolyRefIndex(a_x, a_y) == a_polyref)
                 return; // Found it so return
         }
         a_x = sx + loop;
         for (int j = 0 - (loop - 1); j< loop; j++)
         {
             a_y = sy + j;
             CorrectCoords(a_x, a_y);
             if (SupplyPolyRefIndex(a_x, a_y) == a_polyref)
                 return; // Found it so return
         }
         a_x = sx - loop;
         for (int j = 0 - (loop - 1); j< loop; j++)
         {
             a_y = sy + j;
             CorrectCoords(a_x, a_y);
             if (SupplyPolyRefIndex(a_x, a_y) == a_polyref)
                 return; // Found it so return
         }
         loop++;
     } while (loop<m_width); // This stopping rule should hopefully not be needed, it is set very high.
     g_msg->Warn("Landscape::CentroidSpiralOut: Failure of centroid main loop. Looking for polygon index ",a_polyref);
     a_x = m_elems[a_polyref]->GetMinX();
     a_y = m_elems[a_polyref]->GetMinY();
 }

void Landscape::CentroidSpiralOutBlocks	(	int	a_polyref,
		int &	a_x,
		int &	a_y
	)

Definition at line 2900 of file Landscape.cpp.

 {
     if (SupplyPolyRefIndex(a_x, a_y) == a_polyref) return; // Found it so return
     // Otherwise its not found so we need to start to spiral out until we find a 10x10m block of our field.
     int loop = 1;
     int sx = a_x;
     int sy = a_y;
     do {
         a_y = sy - loop;
         for (int i = 0 - loop; i <= loop; i++)
         {
             a_x = sx + i;
             CorrectCoords(a_x, a_y);
             if (SupplyPolyRefIndex(a_x, a_y) == a_polyref)
             {
                 APoint pt(a_x, a_y);
                 double dists = -1;
                 double best = -1;
                 int ind = -1;
                 for (int d = 0; d < 8; d++)
                 {
                     AxisLoopLtd(a_polyref, &pt, d,10);
 #ifdef __BORLANDC__
                     dists = sqrt(double((a_x - pt.m_x)*(a_x - pt.m_x) + (a_y - pt.m_y) * (a_y - pt.m_y)));
 #else
                     //dists = sqrt((a_x - pt.m_x)*(a_x - pt.m_x) + (a_y - pt.m_y) * (a_y - pt.m_y));
                     dists = (abs(a_x - pt.m_x) + abs(a_y - pt.m_y));
 #endif
                     if (dists > best) { best = dists; ind = d; }
                 }
                 if (ind > -1)
                 {
                     //                  best /= 2;
                     if (best >= 10)
                     {
                         a_x += m_x_add[ind] * 10;
                         a_y += m_y_add[ind] * 10;
                         return;
                     }
                 }
                 return; // Found it so return even without the 10 distance
             }
         }
         a_y = sy + loop;
         for (int i = 0 - loop; i <= loop; i++)
         {
             a_x = sx + i;
             CorrectCoords(a_x, a_y);
             if (SupplyPolyRefIndex(a_x, a_y) == a_polyref)
             {
                 APoint pt(a_x, a_y);
                 double dists = -1;
                 double best = -1;
                 int ind = -1;
                 for (int d = 0; d < 8; d++)
                 {
                     AxisLoopLtd(a_polyref, &pt, d,10);
 #ifdef __BORLANDC__
                     dists = sqrt(double((a_x - pt.m_x)*(a_x - pt.m_x) + (a_y - pt.m_y) * (a_y - pt.m_y)));
 #else
                     //dists = sqrt((a_x - pt.m_x)*(a_x - pt.m_x) + (a_y - pt.m_y) * (a_y - pt.m_y));
                     dists = (abs(a_x - pt.m_x) + abs(a_y - pt.m_y));
 #endif
                     if (dists > best) { best = dists; ind = d; }
                 }
                 if (ind > -1)
                 {
                     //                  best /= 2;
                     if (best >= 10)
                     {
                         a_x += m_x_add[ind] * 10;
                         a_y += m_y_add[ind] * 10;
                         return;
                     }
                 }
                 return; // Found it so return even without the 10 distance
             }
         }
         a_x = sx + loop;
         for (int j = 0 - (loop - 1); j< loop; j++)
         {
             a_y = sy + j;
             CorrectCoords(a_x, a_y);
             if (SupplyPolyRefIndex(a_x, a_y) == a_polyref)
             {
                 APoint pt(a_x, a_y);
                 double dists = -1;
                 double best = -1;
                 int ind = -1;
                 for (int d = 0; d < 8; d++)
                 {
                     AxisLoopLtd(a_polyref, &pt, d,10);
 #ifdef __BORLANDC__
                     dists = sqrt(double((a_x - pt.m_x)*(a_x - pt.m_x) + (a_y - pt.m_y) * (a_y - pt.m_y)));
 #else
                     //dists = sqrt((a_x - pt.m_x)*(a_x - pt.m_x) + (a_y - pt.m_y) * (a_y - pt.m_y));
                     dists = (abs(a_x - pt.m_x) + abs(a_y - pt.m_y));
 #endif
                     if (dists > best) { best = dists; ind = d; }
                 }
                 if (ind > -1)
                 {
                     //                  best /= 2;
                     if (best >= 10)
                     {
                         a_x += m_x_add[ind] * 10;
                         a_y += m_y_add[ind] * 10;
                         return;
                     }
                 }
                 return; // Found it so return even without the 10 distance
             }
         }
         a_x = sx - loop;
         for (int j = 0 - (loop - 1); j< loop; j++)
         {
             a_y = sy + j;
             CorrectCoords(a_x, a_y);
             if (SupplyPolyRefIndex(a_x, a_y) == a_polyref)
             {
                 APoint pt(a_x, a_y);
                 double dists = -1;
                 double best = -1;
                 int ind = -1;
                 for (int d = 0; d < 8; d++)
                 {
                     AxisLoopLtd(a_polyref, &pt, d,10);
 #ifdef __BORLANDC__
                     dists = sqrt(double((a_x - pt.m_x)*(a_x - pt.m_x) + (a_y - pt.m_y) * (a_y - pt.m_y)));
 #else
                     //dists = sqrt((a_x - pt.m_x)*(a_x - pt.m_x) + (a_y - pt.m_y) * (a_y - pt.m_y));
                     dists = (abs(a_x - pt.m_x) + abs(a_y - pt.m_y));
 #endif
                     if (dists > best) { best = dists; ind = d; }
                 }
                 if (ind > -1)
                 {
                     //                  best /= 2;
                     if (best >= 10)
                     {
                         a_x += m_x_add[ind] * 10;
                         a_y += m_y_add[ind] * 10;
                         return;
                     }
                 }
                 return; // Found it so return even without the 10 distance
             }
         }
         loop++;
     } while (loop<m_width); // This stopping rule should hopefully not be needed, it is set very high.
     exit(0);
 }

void Landscape::ChangeMapMapping ( void )

protected

Our map is an array of polygon indentifiers, where we really want to know the associated landscape element of a X-Y coordinate pair.
Changing this to m_elems[] indices will save us one redirection when inquiring information from the landscape, and only costs us the fixed translation step performed here at startup.

Definition at line 1944 of file Landscape.cpp.

References PEST_GRIDSIZE, and PEST_GRIDSIZE_POW2.

                                        {
     cout << "In Change Map Mapping" << endl;
     int mapwidth = m_land->MapWidth();
     int mapheight = m_land->MapHeight();
     int pest_map_width = mapwidth >> PEST_GRIDSIZE_POW2;
     if ( mapwidth & ( PEST_GRIDSIZE - 1 ) ) pest_map_width++;
     int oldindex = -1;
     for ( int x = 0; x < mapwidth; x++ ) 
     {
         for ( int y = 0; y < mapheight; y++ ) 
         {
             int polynum = m_land->Get( x, y ); // the polyref e.g. = 1, m_polymapping[ polynum ] = 0
             m_elems[ m_polymapping[ polynum ]]->SetMapIndex( m_polymapping[ polynum ] ); // Here we set index in the map to the index in elements, i.e. 0
             m_elems[ m_polymapping[ polynum ]]->SetMapValid( true );
             // Do the translation.
             m_land->Put( x, y, m_polymapping[ polynum ] ); // and now we write this to the map, i.e. 0
             // This coordinate is now valid. Throw these coordinates into
             // the associated landscape element.
             int index = m_polymapping[ SupplyPolyRef( x, y ) ];
             if ( index != oldindex ) 
             {
                 m_elems[ index ]->SetValidXY( x, y );
                 int l_x = x >> PEST_GRIDSIZE_POW2;
                 int l_y = y >> PEST_GRIDSIZE_POW2;
                 int pref = l_y * pest_map_width + l_x;        
                 m_elems[ index ]->SetPesticideCell( pref );
                 oldindex = index;
             }
         }
     }
     RebuildPolyMapping(); 
 /*
 // Check that all of the polygons are mentioned in the map.
     if ( l_map_check_polygon_xref.value() ) 
     {
         for ( unsigned int i = 0; i < m_elems.size(); i++ ) 
         {
             if ( !m_elems[ i ]->GetMapValid() ) {
                 char poly[ 20 ];
                 sprintf( poly, "%d", m_elems[ i ]->GetPoly() );
                 g_msg->Warn( WARN_FILE, "Landscape::ChangeMapMapping(): ""Polygon number referenced but not in map file: ", poly );
                 exit( 1 );
             }
         }
     }
 */
 }

bool Landscape::CIPELandscapeMaker ( )

protected

void Landscape::ConsolidatePolys ( void )

protected

Runs through the map checking each cell for polygon type. If it is in our replace list then it re-written as the first instance of that polygon type encountered. All subsequent instances of that type are then deleted.
replaceList contains the types of all tole types with no behaviour that can be consolidated. This list needs to be kept up-to-date.

Definition at line 1175 of file Landscape.cpp.

References g_msg, tole_BareRock, tole_BuiltUpWithParkland, tole_Carpark, tole_Churchyard, tole_Coast, tole_Garden, tole_HeritageSite, tole_IndividualTree, tole_PlantNursery, tole_River, tole_RiversidePlants, tole_RiversideTrees, tole_Saltwater, tole_SandDune, tole_StoneWall, tole_UrbanNoVeg, MapErrorMsg::Warn(), and WARN_FILE.

 {
         const int TypesToReplace = 18;
         TTypesOfLandscapeElement replaceList[TypesToReplace] = { tole_River, tole_RiversidePlants, tole_RiversideTrees, tole_StoneWall, tole_BareRock, tole_BuiltUpWithParkland,
             tole_Carpark, tole_Churchyard, tole_Coast, tole_Garden, tole_HeritageSite,
             tole_IndividualTree, tole_PlantNursery, tole_Saltwater, tole_SandDune, tole_UrbanNoVeg };
         int foundList[TypesToReplace];
         cout << "Consolidating polygons with no special behaviour" << endl;
         for (int i = 0; i < TypesToReplace; i++) foundList[i] = -1;
         int mapwidth = m_land->MapWidth();
         int mapheight = m_land->MapHeight();
         for (int x = 0; x < mapwidth; x++) 
         {
             for (int y = 0; y < mapheight; y++) 
             {
                 int ele = m_land->Get(x, y);
                 TTypesOfLandscapeElement tole = m_elems[m_polymapping[ele]]->GetElementType();
                 for (int t = 0; t < TypesToReplace; t++) 
                 {
                     if (tole == replaceList[t])
                     {
                         // Must do something with this cell
                         if (foundList[t] == -1) foundList[t] = ele;
                         else
                         {
                             // Need to replace this cell
                             m_land->Put(x, y, foundList[t]);
                         }
                     }
                 }
             }
         }
     // At this point there should be many polygons that are not in the map. So we need to run the valid test.
     g_msg->Warn(WARN_FILE, "Landscape::ConsolidatePolys() - ""Consolidate map dump.", "");
 }

void Landscape::CorrectCoords	(	int &	x,
		int &	y
	)

inline

Function to prevent wrap around errors with co-ordinates using x/y pair.

m_width10 & m_height10 are used to avoid problems with co-ordinate values that are very large. Problems will only occur if coords passed are >10x the world width or height.

Definition at line 1461 of file landscape.h.

 {
     x = (m_width10 + x) % m_width;
     y = (m_height10 + y) % m_height;
 }

void Landscape::CorrectCoordsPointNoWrap ( APoint & a_pt )

inline

Function to prevent wrap around errors with co-ordinates using a APoint.

This just cuts off extremes of coordinate values so that the point stays in landscape. Can't use a modulus or we get wrap around, and in this case we don't want that

Definition at line 1481 of file landscape.h.

 {
     if (a_pt.m_x >= m_width) a_pt.m_x = m_width - 1;
     if (a_pt.m_y >= m_height) a_pt.m_y = m_height - 1;
     if (a_pt.m_x < 0) a_pt.m_x = 0;
     if (a_pt.m_y < 0) a_pt.m_y = 0;
 }

APoint Landscape::CorrectCoordsPt	(	int	x,
		int	y
	)

inline

Function to prevent wrap around errors with co-ordinates using x/y pair.

m_width10 & m_height10 are used to avoid problems with co-ordinate values that are very large. Problems will only occur if coords passed are >10x the world width or height.

Definition at line 1470 of file landscape.h.

 {
     APoint pt;
     pt.m_x = (m_width10 + x) % m_width;
     pt.m_y = (m_height10 + y) % m_height;
     return pt;
 }

int Landscape::CorrectHeight ( int y )

inline

Definition at line 1499 of file landscape.h.

 {
   return (m_height10+y)%m_height;
 }

int Landscape::CorrectWidth ( int x )

inline

Definition at line 1493 of file landscape.h.

 {
    return (m_width10+x)%m_width;
 }

void Landscape::CountMapSquares ( void )

protected

Definition at line 1854 of file Landscape.cpp.

                                       {
     int mapwidth = m_land->MapWidth();
     int mapheight = m_land->MapHeight();
     for ( unsigned int i = 0; i < m_elems.size(); i++ ) {
         m_elems[i]->SetArea(0);
         m_elems[ i ]->m_squares_in_map=0;
     }
 
     for ( int x = 0; x < mapwidth; x++ ) {
         for ( int y = 0; y < mapheight; y++ ) {
             int l_ele = m_land->Get( x, y );
             m_elems[ l_ele ]->m_squares_in_map++;
         }
     }
 }

void Landscape::CreatePondList ( )

protected

Creates a list of pond polygon refs/indexes for easy look up.

Just creates an unordered list of polyref numbers and m_elems indices for all ponds. This is for easy look-up by e.g. newts

Definition at line 2375 of file Landscape.cpp.

References tole_Pond.

 {
     for (unsigned int i = 0; i < m_elems.size(); i++)
     {
         if (m_elems[i]->GetElementType() == tole_Pond) {
             m_PondIndexList.push_back(i);
             m_PondRefsList.push_back(m_elems[i]->GetPoly());
         }
     }
 }

void Landscape::DegreesDump ( )

protected

Prints the sum of day degrees. See FarmManager::daydegrees.

Definition at line 1498 of file Landscape.cpp.

                            {
 
     ofstream ofile ("Daydegrees.txt", ios::app);    
     //print degrees
     ofile << m_FarmManager->GetDD();
     ofile  << endl;
     ofile.close();
 }

void Landscape::DumpAllSymbolsAndExit ( const char * a_dumpfile )

inline

Definition at line 734 of file landscape.h.

References Configurator::DumpAllSymbolsAndExit(), and g_cfg.

                                                        {
     g_cfg->DumpAllSymbolsAndExit( a_dumpfile );
   }

void Landscape::DumpCentroids ( void )

Definition at line 3054 of file Landscape.cpp.

 {
     ofstream centroidfile("PolygonCentroids.txt", ios::out);
     centroidfile<<"Polyref"<<'\t'<<"CX"<<'\t'<<"CY"<<'\t'<<"Type"<<'\t'<<"Area"<<'\t'<<"Country Designation"<<endl;
     for (int p = 0; p< (int)m_elems.size(); p++)
     {
         centroidfile<<m_elems[p]->GetPoly()<<'\t'<<m_elems[p]->GetCentroidX()<<'\t'<<m_elems[p]->GetCentroidY()<<'\t'<<m_elems[p]->GetElementType()<<'\t'<<m_elems[p]->GetArea()<<'\t'<<m_elems[p]->GetCountryDesignation()<<endl;
     }
     centroidfile.close();
 }

void Landscape::DumpMap ( const char * a_filename )

protected

Definition at line 1217 of file Landscape.cpp.

 {
     int * l_map = m_land->GetMagicP(0, 0); // Hmmm - this is a nasty way round the class data protection. Gets a pointer direct to m_map in rastermap.
     /*  FILE * l_file;
   l_file = fopen(a_filename, "wb" );
   if ( !l_file ) {
     g_msg->Warn( WARN_FILE, "Landscape::DumpMap(): Unable to open file", a_filename );
     exit( 0 );
   }
 
   char * l_id = m_land->GetID();
 
 
       fwrite( l_id, 1, 12, l_file );
   fwrite( & m_width, 1, sizeof( int ), l_file );
   if (cfg_rectangularmaps_on.value() )
   {
       fwrite( & m_height, 1, sizeof( int ), l_file );
   }
   for ( int i = 0; i < m_width * m_height; i++ ) 
   {
         LE* le = m_elems[m_polymapping[l_map[i]]];
         int l_poly = le->GetPoly();
         fwrite( & l_poly, 1, sizeof( int ), l_file );
   }
   fclose( l_file );
   */
     ofstream OFile( a_filename, ios::binary);
   char id[12] = { "LSB2_Format" };
   OFile.write(id, 12);
   OFile.write((char*)&m_width, sizeof (int));
   OFile.write((char*)&m_height, sizeof (int));
   OFile.write((char*)l_map, m_width*m_height*sizeof (int));
   OFile.close();
 }

void Landscape::DumpMapGraphics ( const char * a_filename )

protected

Definition at line 3363 of file Landscape.cpp.

References g_msg, tole_Field, MapErrorMsg::Warn(), and WARN_FILE.

                                                        {
     unsigned int linesize = m_maxextent * 3;
     unsigned char * frame_buffer = (unsigned char *)malloc(sizeof(unsigned char)* linesize);
 
     if (frame_buffer == NULL) {
         g_msg->Warn(WARN_FILE, "Landscape::DumpMapGraphics(): Out of memory!", "");
         exit(1);
     }
 
     FILE * l_file = fopen(a_filename, "w");
     if (!l_file) {
         g_msg->Warn(WARN_FILE, "Landscape::DumpMapGraphics(): ""Unable to open file for writing: %s\n", a_filename);
         exit(1);
     }
 
     fprintf(l_file, "P6\n%d %d %d\n", m_width, m_height, 255);
 
     for (int y = 0; y < m_height; y++) {
         int i = 0;
         for (int x = 0; x < m_width; x++) {
             int eletype = (int)SupplyElementType(x, y);
             int localcolor = 16777215 / eletype;
 
             if (eletype == (int)tole_Field) {
                 int category;
                 double hei = SupplyVegHeight(x, y);
                 if (hei > 50.0) category = 0; else category = (int)(200.0 - (hei * 4.0));
                 localcolor = ((category * 65536) + 65535);
             }
 
             frame_buffer[i++] = (unsigned char)(localcolor & 0xff);
             frame_buffer[i++] = (unsigned char)((localcolor >> 8) & 0xff);
             frame_buffer[i++] = (unsigned char)((localcolor >> 16) & 0xff);
         }
         fwrite(frame_buffer, sizeof(unsigned char), linesize, l_file);
     }
 
     fclose(l_file);
 
     free(frame_buffer);
 }

void Landscape::DumpMapInfoByArea	(	const char *	a_filename,
		bool	a_append,
		bool	a_dump_zero_areas,
		bool	a_write_veg_names
	)

Definition at line 3416 of file Landscape.cpp.

References Calendar::DayInYear(), g_date, g_msg, Calendar::OldDays(), tov_OFirstYearDanger, tov_Undefined, MapErrorMsg::Warn(), and WARN_FILE.

                                                                                                                         {
     FillVegAreaData();
     FILE * outf;
     if (a_append) {
         outf = fopen(a_filename, "a");
         if (!outf) {
             g_msg->Warn(WARN_FILE, "Landscape::DumpMapInfoByArea(): ""Unable to open file for appending", a_filename);
             exit(1);
         }
     }
     else {
         outf = fopen(a_filename, "w");
         if (!outf) {
             g_msg->Warn(WARN_FILE, "Landscape::DumpMapInfoByArea(): ""Unable to open file for writing", a_filename);
             exit(1);
         }
     }
 
     // Emit element type info.
     for (unsigned int i = 0; i < tov_Undefined + 1; i++) {
         if (i == tov_OFirstYearDanger)
             continue;
         if (!a_dump_zero_areas && l_vegtype_areas[i] < 0.5)
             continue;
 
         fprintf(outf, "%6ld\t%3d\t%10.0f", g_date->OldDays() + g_date->DayInYear() - 364, i, l_vegtype_areas[i]);
         if (a_write_veg_names)
             fprintf(outf, "\t%s\n", VegtypeToString((TTypesOfVegetation)i).c_str()); else
             fprintf(outf, "\n");
     }
 
     fclose(outf);
 }

void Landscape::DumpPublicSymbols	(	const char *	a_dumpfile,
		CfgSecureLevel	a_level
	)

inline

Definition at line 730 of file landscape.h.

References Configurator::DumpPublicSymbols(), and g_cfg.

                                        {
     g_cfg->DumpPublicSymbols( a_dumpfile, a_level );
   }

void Landscape::DumpTreatCounters ( const char * a_filename )

protected

Definition at line 3350 of file Landscape.cpp.

References g_msg, last_treatment, start, MapErrorMsg::Warn(), and WARN_FILE.

                                                          {
     FILE * l_file = fopen(a_filename, "w");
     if (!l_file) {
         g_msg->Warn(WARN_FILE, "Landscape::DumpTreatCounters(): ""Unable to open file for writing: %s\n", a_filename);
         exit(1);
     }
 
     for (int i = start; i < last_treatment; i++) {
         fprintf(l_file, "%3d %s %10d\n", i, EventtypeToString(i).c_str(), m_treatment_counts[i]);
     }
     fclose(l_file);
 }

void Landscape::DumpVegAreaData ( int a_day )

Definition at line 4295 of file Landscape.cpp.

References cfg_dumpvegjan, cfg_dumpvegjanfile, cfg_dumpvegjune, cfg_dumpvegjunefile, CfgBool::value(), and CfgStr::value().

                                          {
 
     if (cfg_dumpvegjan.value()) {
         if ((a_day % 365) == 0) { // Jan 1st
             DumpMapInfoByArea(cfg_dumpvegjanfile.value(), true, true, true);
             return;
         }
     }
     if (cfg_dumpvegjune.value()) {
         if ((a_day % 365) == 152) { // 1st June
             DumpMapInfoByArea(cfg_dumpvegjunefile.value(), true, true, true);
         }
     }
 
 }

void Landscape::EventDump	(	int	x,
		int	y,
		int	x2,
		int	y2
	)

protected

Definition at line 1508 of file Landscape.cpp.

References g_msg, sleep_all_day, MapErrorMsg::Warn(), and WARN_FILE.

                                                           {
   FILE * vfile=fopen("EventDump.txt", "a" );
   if (!vfile) {
     g_msg->Warn( WARN_FILE, "Landscape::EventDump(): Unable to open file", "EventDump.txt" );
     exit( 1 );
   }
   FarmToDo event;
   int i = 0;
   int day = SupplyDayInYear();
   fprintf( vfile, "%d: ", day );
   while ( ( event = ( FarmToDo )SupplyLastTreatment( x1, y1, & i ) ) != sleep_all_day ) {
     fprintf( vfile, "%d ", event );
   }
   i = 0;
   fprintf( vfile, " - " );
   while ( ( event = ( FarmToDo )SupplyLastTreatment( x2, y2, & i ) ) != sleep_all_day ) {
     fprintf( vfile, "%d ", event );
   }
   fprintf( vfile, "\n" );
   fclose( vfile );
 }

void Landscape::EventDumpPesticides	(	int	x1,
		int	y1
	)

protected

Definition at line 1531 of file Landscape.cpp.

References fungicide_treat, g_msg, herbicide_treat, insecticide_treat, sleep_all_day, MapErrorMsg::Warn(), and WARN_FILE.

                                                     {
   FILE * vfile=fopen("EventDump.txt", "a" );
   if (!vfile) {
     g_msg->Warn( WARN_FILE, "Landscape::EventDump(): Unable to open file", "EventDump.txt" );
     exit( 1 );
   }
   FarmToDo a_event;
   int i = 0;
   int day = this->SupplyGlobalDate();
   int herb = 0;
   int fung = 0;
   int ins = 0;
   while ( ( a_event = ( FarmToDo )SupplyLastTreatment( x1, y1, & i ) ) != sleep_all_day ) {
       if (a_event == herbicide_treat )
       {
               herb++;
       }
       else if (a_event == fungicide_treat ) fung++;
       else if (a_event == insecticide_treat) ins++;
   }
   if (herb+fung+ins >0 ) fprintf( vfile, "%d\t%d\t%d\t%d\n", day, herb, fung, ins );
   i = 0;
   fclose( vfile );
 }

std::string Landscape::EventtypeToString ( int a_event )

Definition at line 3670 of file Landscape.cpp.

References autumn_harrow, autumn_or_spring_plough, autumn_plough, autumn_roll, autumn_sow, burn_straw_stubble, cattle_out, cut_to_hay, cut_to_silage, cut_weeds, deep_ploughing, fa_ammoniumsulphate, fa_greenmanure, fa_manure, fa_npk, fa_pk, fa_sludge, fa_slurry, flammebehandling, fp_greenmanure, fp_liquidNH3, fp_manganesesulphate, fp_manure, fp_npk, fp_npks, fp_pk, fp_sludge, fp_slurry, fungicide_treat, g_msg, glyphosate, growth_regulator, harvest, hay_bailing, hay_turning, herbicide_treat, hilling_up, insecticide_treat, molluscicide, mow, pigs_out, product_treat, row_cultivation, sleep_all_day, spring_harrow, spring_plough, spring_roll, spring_sow, start, straw_chopping, strigling, strigling_sow, stubble_harrowing, swathing, syninsecticide_treat, trial_control, trial_insecticidetreat, trial_toxiccontrol, MapErrorMsg::Warn(), WARN_FILE, water, and winter_plough.

                                                   {
     char error_num[20];
 
     switch (a_event) {
     case start:
         return "                  start";
     case sleep_all_day:
         return "          sleep_all_day";
     case autumn_plough:
         return "          autumn_plough";
     case autumn_harrow:
         return "          autumn_harrow";
     case autumn_roll:
         return "            autumn_roll";
     case autumn_sow:
         return "             autumn_sow";
     case winter_plough:
         return "          winter_plough";
     case deep_ploughing:
         return "         deep_ploughing";
     case spring_plough:
         return "          spring_plough";
     case spring_harrow:
         return "          spring_harrow";
     case spring_roll:
         return "            spring_roll";
     case spring_sow:
         return "             spring_sow";
     case fp_npks:
         return "                fp_npks";
     case fp_npk:
         return "                 fp_npk";
     case fp_pk:
         return "                  fp_pk";
     case fp_liquidNH3:
         return "           fp_liquidNH3";
     case fp_slurry:
         return "              fp_slurry";
     case fp_manganesesulphate:
         return "   fp_manganesesulphate";
     case fp_manure:
         return "              fp_manure";
     case fp_greenmanure:
         return "         fp_greenmanure";
     case fp_sludge:
         return "              fp_sludge";
     case fa_npk:
         return "                 fa_npk";
     case fa_pk:
         return "                  fa_pk";
     case fa_slurry:
         return "              fa_slurry";
     case fa_ammoniumsulphate:
         return "    fa_ammoniumsulphate";
     case fa_manure:
         return "              fa_manure";
     case fa_greenmanure:
         return "         fa_greenmanure";
     case fa_sludge:
         return "              fa_sludge";
     case herbicide_treat:
         return "        herbicide_treat";
     case growth_regulator:
         return "       growth_regulator";
     case fungicide_treat:
         return "        fungicide_treat";
     case insecticide_treat:
         return "      insecticide_treat";
     case product_treat:
         return "pesticide_product_treat";
     case syninsecticide_treat:
         return "   syninsecticide_treat";
     case molluscicide:
         return "           molluscicide";
     case row_cultivation:
         return "        row_cultivation";
     case strigling:
         return "              strigling";
     case flammebehandling:
         return "       flammebehandling";
     case hilling_up:
         return "             hilling_up";
     case water:
         return "                  water";
     case swathing:
         return "               swathing";
     case harvest:
         return "                harvest";
     case cattle_out:
         return "             cattle_out";
     case pigs_out:
         return "               pigs_out";
     case cut_to_hay:
         return "             cut_to_hay";
     case cut_to_silage:
         return "          cut_to_silage";
     case straw_chopping:
         return "         straw_chopping";
     case hay_turning:
         return "            hay_turning";
     case hay_bailing:
         return "            hay_bailing";
     case stubble_harrowing:
         return "      stubble_harrowing";
     case autumn_or_spring_plough:
         return "autumn_or_spring_plough";
     case burn_straw_stubble:
         return "     burn_straw_stubble";
     case mow:
         return "                    mow";
     case cut_weeds:
         return "              cut_weeds";
     case strigling_sow:
         return "          strigling_sow";
     case trial_insecticidetreat:
         return "PesticideTrialTreatment";
     case trial_toxiccontrol:
         return "    PesticideTrialToxic";
     case trial_control:
         return "  PesticideTrialControl";
     case glyphosate:
         return " Glyphosate on setaside";
     default:
         sprintf(error_num, "%d", a_event);
         g_msg->Warn(WARN_FILE, "Landscape::EventtypeToString(): Unknown event type:", error_num);
         exit(1);
     }
 }

void Landscape::FillVegAreaData ( )

Definition at line 3405 of file Landscape.cpp.

References tov_Undefined.

                                 {
     for (unsigned int i = 0; i < (tov_Undefined + 1); i++) {
         l_vegtype_areas[i] = 0.0;
     }
 
     // Sum up statistics on element type.
     for (unsigned int i = 0; i < m_elems.size(); i++) {
         l_vegtype_areas[m_elems[i]->GetVegType()] += m_elems[i]->GetArea();
     }
 }

bool Landscape::FindFieldCenter	(	LE *	a_field,
		int *	x,
		int *	y
	)

protected

Definition at line 2580 of file Landscape.cpp.

References LE::GetPoly().

                                                            {
     // Start at x,y
     // works by selecting the point that is a mean of the co-ords of the centers of 4 axes from this point that are in the field.
     // Then do it again, and again until we don't move more than 1m or we have tried too many times
     int ourpoly=SupplyPolyRef(*(x),*(y));
     if (ourpoly!=a_field->GetPoly()) return false;
     int centers[2][8];
     int tries=0;
     int diff=999;
     int x1=*(x);
     int y1=*(y);
     int centreX=x1;
     int centreY=y1;
     // NB we might escape without bounds checking here because the polygon number does not wrap round - will only ever be a problem if we go SimX+1,SimY+1
     while ((diff>1) & (tries++<100)) {
         for (unsigned v=0; v<4; v++) {
             x1=centreX;
             y1=centreY;
             AxisLoop(ourpoly, &x1, &y1, v);
             centers[0][v]=x1-m_x_add[v];
             centers[1][v]=y1-m_y_add[v];
             x1=centreX;
             y1=centreY;
             AxisLoop(ourpoly, &x1, &y1, v+4);
             centers[0][v+4]=x1-m_x_add[v+4];
             centers[1][v+4]=y1-m_y_add[v+4];
 //          centreX+=((centers[0][v]+x1-m_x_add[v+4])/2);
 //          centreY+=((centers[1][v]+y1-m_y_add[v+4])/2);
         }
         int oldx=centreX;
         int oldy=centreY;
         centreX=0;
         centreY=0;
         for (int h=0; h<8; h++) {
             centreX+=centers[0][h];
             centreY+=centers[1][h];
         }
         centreX/=8;
         centreY/=8;
         diff=abs(oldx-centreX)+abs(oldy-centreY);
     }
     *(x)=centreX;
     *(y)=centreY;
     int tourpoly=SupplyPolyRef(*(x),*(y));
     if (tourpoly!=ourpoly) {
         return false; // can happen eg if there is a pond in the middle of the field
     }
 
     return true;
 }

int Landscape::FindLongestAxis	(	int *	x,
		int *	y,
		int *	a_length
	)

protected

Definition at line 2632 of file Landscape.cpp.

 {
     int ourpoly=SupplyPolyRef(*(a_x),*(a_y));
     int dist[4];
     int distx[8];
     int disty[8];
     int found = -1;
     *(a_length) = 0;
     int dx[8];
     int dy[8];
     int fx[8];
     int fy[8];
     for (unsigned v=0; v<8; v++) 
     {
         int x1=*(a_x);
         int y1=*(a_y);
         AxisLoop(ourpoly, &x1, &y1, v);
         x1 -= m_x_add[v];
         y1 -= m_y_add[v];
         dx[v] = abs(*(a_x)-x1);
         dy[v] = abs(*(a_y)-y1);
         fx[v] = x1;
         fy[v] = y1;
         distx[v] = dx[v];
         disty[v] = dy[v];
     }
     for (int di = 0; di < 4; di++)
     {
         int dx = distx[di] + distx[di + 4];
         int dy = disty[di] + disty[di + 4];
         if (dx == 0) dist[di] = dy; else dist[di] = dx;
         if (dist[di] > *(a_length))
         {
             found = di;
             *(a_length) = dist[di];
         }
     }
     if (found == -1) return 0;
     // Now need to find the middle of the axis.
     int l = (*(a_length) / 2);
     if (fx[found] > fx[found + 4]) *(a_x) = fx[found + 4] + m_x_add[found] * l;  else *(a_x) = fx[found + 4] - m_x_add[found + 4] * l;
     if (fy[found] > fy[found + 4]) *(a_y) = fy[found + 4] + m_y_add[found] * l;  else *(a_y) = fy[found + 4] - m_y_add[found + 4] * l;
 
     return found;
 }

bool Landscape::FindValidXY	(	int	a_field,
		int &	a_x,
		int &	a_y
	)

protected

Definition at line 2469 of file Landscape.cpp.

                                                                {
   // From a hopefully sensible starting point this method scans in the
   // 8 directions to find a good valid x and y matching a_field
   int x_add[ 8 ] = { 1, 1, 0, -1, -1, -1, 0, 1 };
   int y_add[ 8 ] = { 0, -1, -1, -1, 0, 1, 1, 1 };
   int index;
   int nx, ny;
   int width = m_land->MapWidth();
   int height = m_land->MapHeight();
   // Assume it has to within 100m
   for ( int i = 0; i < 100; i++ ) {
     for ( int l = 0; l < 8; l++ ) {
       nx = a_x + x_add[ l ] * i;
       ny = a_y + y_add[ l ] * i;
       if ( ( nx < width ) && ( nx >= 0 ) && ( ny < height ) && ( ny >= 0 ) ) {
         index = m_land->Get( nx, ny );
         if ( index == a_field ) {
           a_x = a_x + x_add[ l ] * i;
           a_y = a_y + y_add[ l ] * i;
           return true;
         }
       }
     }
   }
   return false;
 }

void Landscape::ForceArea ( void )

protected

Definition at line 1886 of file Landscape.cpp.

References g_msg, MapErrorMsg::Warn(), and WARN_BUG.

                                 {
   int l_area_sum = 0;
 
   for ( unsigned int i = 0; i < m_elems.size(); i++ ) {
     m_elems[ i ]->SetArea( ( double )m_elems[ i ]->m_squares_in_map );
     if ( m_elems[ i ]->m_squares_in_map > 0 ) {
       m_elems[ i ]->SetMapValid( true );
       l_area_sum += m_elems[ i ]->m_squares_in_map;
     }
   }
 
   if ( l_area_sum != m_width * m_height ) {
     g_msg->Warn( WARN_BUG, "Landscape::ForceArea(): Polygon areas doesn't"" sum up to map area!", "" );
     exit( 1 );
   }
 }

double Landscape::GetActualGooseGrazingForage	(	int	a_x,
		int	a_y,
		GooseSpecies	a_goose
	)

inline

Returns the leaf forage resource as seen from a goose standpoint at a polygon referenced by x,y location.

Parameters

a_x	[in] The x-coordinate in a polygon we are interested in (assumed grass or cereals). This needs to be checked before calling
a_y	[in] The x-coordinate in a polygon we are interested in (assumed grass or cereals). This needs to be checked before calling
a_goose	[in] Is the type of goose calling which is needed to determine how to assess the value of the current forage availability (ie its different for different types of geese)

Returns: KJ/min

Definition at line 559 of file landscape.h.

References RasterMap::Get().

   {
       return m_elems[m_land->Get(a_x, a_y)]->GetGooseGrazingForage(a_goose);
   }

double Landscape::GetActualGooseGrazingForage	(	int	a_polygon,
		GooseSpecies	a_goose
	)

inline

Returns the leaf forage resource as seen from a goose standpoint at a polygon referenced by x,y location The amount of food avaiable as grazing resource based on the vegetation height is species specific.

Parameters

a_polygon	[in] The polygon refence number for the polygon we are interested in (assumed grass or cereals). This needs to be checked before calling
a_goose	[in] Is the type of goose calling which is needed to determine how to assess the value of the current forage availability (ie its different for different types of geese)

Returns: KJ/min

Definition at line 570 of file landscape.h.

References m_polymapping.

   {
       return m_elems[m_polymapping[a_polygon]]->GetGooseGrazingForage(a_goose);
   }

GooseFieldList * Landscape::GetGooseFields ( double a_minopenness )

Gets the list of suitable goose foraging fields today.

Here we need to go through all possible goose feeding locations to find out if they have any forage in them, and then create a list of those to return.
To make this efficient we need to have a list of fields.

First must calculate centroid. Runs through the list of elements and any that have an openness score bigger than our target are saved.

Definition at line 564 of file Landscape.cpp.

 {
     GooseFieldList* alist = new GooseFieldList;
     GooseFieldListItem gfli;
     for (unsigned int i = 0; i < m_elems.size(); i++)
     {
         if (m_elems[i]->GetOpenness() > a_minopenness)
         {
             for (int g = gs_Pinkfoot; g < gs_foobar; g++)
             {
                 gfli.grass[g] = m_elems[i]->GetGooseGrazingForage((GooseSpecies)g);
                 gfli.geesesp[g] = m_elems[i]->GetGooseSpNosToday((GooseSpecies)g);
                 gfli.geesespTimed[g] = m_elems[i]->GetGooseSpNosTodayTimed((GooseSpecies)g);
             }
             gfli.grain = m_elems[i]->GetBirdSeed();
             gfli.maize = m_elems[ i ]->GetBirdMaize(); 
             gfli.openness = m_elems[ i ]->GetOpenness();
             int pref = m_elems[ i ]->GetPoly();
             gfli.polyref = pref;
             gfli.geese = m_elems[i]->GetGooseNosToday();
             gfli.geeseTimed = m_elems[i]->GetGooseNosTodayTimed();
             gfli.vegtype = m_elems[i]->GetVegType();
             gfli.vegtypechr = VegtypeToString(m_elems[i]->GetVegType());
             gfli.vegheight = m_elems[i]->GetVegHeight();
             gfli.digestability = m_elems[i]->GetDigestability();
             gfli.vegphase = m_elems[i]->GetVegPhase();
             gfli.previouscrop = VegtypeToString( m_elems[ i ]->GetPreviousCrop( m_elems[ i ]->GetRotIndex() ) );
             gfli.lastsownveg = VegtypeToString( m_elems[ i ]->GetLastSownVeg() );
             alist->push_back(gfli);
         }
     }
     return alist;
 }

int Landscape::GetGooseNumbers ( int a_poly )

This returns the number of geese on the polygon the day before.

Definition at line 3154 of file Landscape.cpp.

                                               {
       return m_elems[m_polymapping[a_polyref]]->GetGooseNos();
   }

int Landscape::GetGooseNumbers	(	int	a_x,
		int	a_y
	)

This returns the number of geese on the polygon specifed by a_x, a_y the day before.

This returns the number of geese on the polygon the day before.

Definition at line 3162 of file Landscape.cpp.

   {
       return m_elems[m_land->Get(a_x, a_y)]->GetGooseNos();
   }

double Landscape::GetHareFoodQuality ( int a_polygon )

Todo:: Decide where to classify new LE types for hare 1

Definition at line 3168 of file Landscape.cpp.

References g_FarmIntensivenessH, tole_ActivePit, tole_AmenityGrass, tole_BareRock, tole_Building, tole_BuiltUpWithParkland, tole_Carpark, tole_Churchyard, tole_Coast, tole_ConiferousForest, tole_Copse, tole_DeciduousForest, tole_FishFarm, tole_Freshwater, tole_Garden, tole_Hedges, tole_HeritageSite, tole_IndividualTree, tole_LargeRoad, tole_Marsh, tole_MetalledPath, tole_MixedForest, tole_Parkland, tole_PitDisused, tole_PlantNursery, tole_Pond, tole_Pylon, tole_Railway, tole_River, tole_RiversidePlants, tole_RiversideTrees, tole_RoadsideVerge, tole_Saltwater, tole_SandDune, tole_Scrub, tole_SmallRoad, tole_StoneWall, tole_Stream, tole_Track, tole_UrbanNoVeg, tole_UrbanPark, tole_Vildtager, tole_Wasteland, tole_WindTurbine, tole_WoodlandMargin, and tole_WoodyEnergyCrop.

 {
           double digest;
           TTypesOfLandscapeElement habitat = SupplyElementType(a_polygon);
           switch (habitat) {
               // Impossible stuff
           case tole_Building:
           case tole_Pond:
           case tole_Freshwater:
           case tole_River:
           case tole_Saltwater:
           case tole_Coast:
           case tole_BareRock:
           case tole_ConiferousForest:
           case tole_DeciduousForest:
           case tole_MixedForest:
           case tole_SmallRoad:
           case tole_LargeRoad:
           case tole_ActivePit:
           case tole_UrbanNoVeg:
           case tole_UrbanPark:
           case tole_SandDune:
           case tole_Copse:
           case tole_Stream:
           case tole_MetalledPath:
           case tole_Carpark:
           case tole_FishFarm:
               //            EnergyBalance(activity_Foraging, 100); // This is a bug - it penalises for foraging in impossible areas - not intended but not found until after parameter fitting! Removed 28/07/2014
               return 0.0;
 
               // Questionable stuff
           case tole_RiversidePlants:
           case tole_RiversideTrees:
           case tole_Garden:
           case tole_Track:
           case tole_StoneWall:
           case tole_Hedges:
           case tole_Marsh:
           case tole_PitDisused:
           case tole_RoadsideVerge:
           case tole_Railway:
           case tole_Scrub:
           case tole_AmenityGrass:
           case tole_Parkland:
           case tole_BuiltUpWithParkland:
           case tole_Churchyard:
           case tole_HeritageSite:
               return 0.25; // was 0.25  being half of access to low digestability stuff
               //        case tole_MownGrass:
               //            digest = 0.8;  // Added 28/07/2014 this is a way to compensate for the lack of choice when foraging, i.e. the whole area  is assumed to be foraged equally.
           case tole_Wasteland:
           case tole_IndividualTree:
           case tole_WoodyEnergyCrop:
           case tole_PlantNursery:
           case tole_Pylon:
           case tole_WindTurbine:
           case tole_WoodlandMargin:
           case tole_Vildtager:
           default:
               digest = SupplyVegDigestability(a_polygon);
           }
 #ifdef __Perfectfood
           return 0.8;
 #else
 #ifdef __YEARLYVARIABLEFOODQUALITY
           digest *= m_OurPopulationManager->m_GoodYearBadYear;
 #endif
           double veg_height;
           double access = 1.0;
           // double grazedreduction[4] = { 1.0, 0.75, 0.5, 0.25 };
           double grazedreduction[4] = { 1.0, 0.8, 0.2, 0.05 };
           veg_height = SupplyVegHeight(a_polygon);
           double weeds = SupplyWeedBiomass(a_polygon);
           if ((veg_height <= 0) && (weeds < 0.1)) return 0.25; // Always something to eat, but not much.
 #ifdef __Hare1950s
           bool veg_patchy = true;
 #else   // If it is not the special case of the 1950s
           //
           bool veg_patchy = SupplyVegPatchy(a_polygon);
 #endif
           if (veg_patchy)
           {
               // Patchy vegetation - normally full access
               if (veg_height>50)
               {
                   // no food at only at very very tall
                   access -= ((veg_height - 50)* g_VegHeightForageReduction);
                   if (access<0) access = 0;
               }
           }
           else
           {
               if (veg_height>g_FarmIntensivenessH)
               {
                   access -= ((veg_height - g_FarmIntensivenessH)* /* g_FarmIntensiveness * */ g_VegHeightForageReduction);
                   if (access<0) access = 0;
               }
           }
           return access * digest * grazedreduction[SupplyGrazingPressure(a_polygon)];
 #endif
 }

APoint Landscape::GetNextSeed ( int )

protected

double Landscape::GetVegArea ( int v )

inline

Definition at line 154 of file landscape.h.

154 { return l_vegtype_areas[v]; }

Landscape::l_vegtype_areas

double * l_vegtype_areas

Definition: landscape.h:141

void Landscape::GISASCII_Output	(	string	outpfile,
		int	UTMX,
		int	UTMY
	)

protected

Write ASCII file of the ALMaSS map.

Here we write a ASCII file of the current map. Useful when visualizing output from simulations. The function will output the entity that is defined in the config: l_map_ascii_map_entity. The default is polyref number (l_map_ascii_map_entity = 1).

Parameters

[in]	outpfile	Name of the output file
[in]	UTMX	Utm x-coordinate of the lower lefthand corner of the map
[in]	UTMY	Utm y-coordinate of the lower lefthand corner of the map

Definition at line 3271 of file Landscape.cpp.

References g_msg, l_map_ascii_map_entity, CfgInt::value(), MapErrorMsg::Warn(), and WARN_FILE.

                                                                      {
     FILE* OFILE;
     OFILE = fopen( outpfile.c_str(), "w" );
     if (!OFILE) {
         g_msg->Warn( WARN_FILE, "Landscape::GISASCII_Output() "
             "Unable to open file for writing:",
             outpfile );
         exit( 1 );
     }
     char c = '\n';
     fprintf(OFILE, "ncols         %d\n", m_width);
     fprintf(OFILE, "nrows         %d\n", m_height);
     fprintf(OFILE, "xllcorner     %d\n", UTMX );
     fprintf(OFILE, "yllcorner     %d\n", UTMY );
     fprintf(OFILE, "cellsize      %d\n", 1 );
     fprintf(OFILE, "NODATA_value  %d\n", -9999 );
     // The polyref loop
     if (l_map_ascii_map_entity.value() == 1) {
         for (int y = 0; y < m_height; y++) {
             for (int x = 0; x < m_width; x++) {
                 fprintf(OFILE, "%d\t", SupplyPolyRef(x, y));
             }
             fprintf(OFILE, "%c", c );
         }
     }
     // The element type loop
     if (l_map_ascii_map_entity.value() == 2) {
         for (int y = 0; y < m_height; y++) {
             for (int x = 0; x < m_width; x++) {
                 fprintf(OFILE, "%d\t", SupplyElementType( x, y ));
             }
             fprintf( OFILE, "%c", c );
         }
     }
     fclose( OFILE );
 }

void Landscape::GrazeVegetation	(	int	a_poly,
		double	a_forage
	)

inline

Removes grazing forage from a poly per m2.

Definition at line 623 of file landscape.h.

References m_polymapping.

                                                       {
       m_elems[ m_polymapping[ a_poly ] ]->GrazeVegetation( a_forage, true );
   }

void Landscape::GrazeVegetationTotal	(	int	a_poly,
		double	a_forage
	)

inline

Removes grazing forage from a poly and divides this out per m2.

Definition at line 629 of file landscape.h.

References m_polymapping.

                                                            {
       m_elems[ m_polymapping[ a_poly ] ]->GrazeVegetationTotal( a_forage );
   }

void Landscape::hb_Add ( void )

protected

Definition at line 56 of file hedgebanks.cpp.

References RasterMap::GetMagicP(), hb_AddNewHedgebanks(), hb_border_pixels, hb_ClearPolygon(), hb_core_pixels, hb_DownPolyNumbers(), hb_FindBoundingBox(), hb_FindHedges(), hb_hedges, hb_height, HB_MAGIC, hb_map, hb_MarkTheBresenhamWay(), hb_MarkTopFromLocalMax(), hb_PaintBorder(), hb_PaintWhoHasNeighbourColor(), hb_ResetColorBits(), hb_RestoreHedgeCore(), hb_size, hb_UpPolyNumbers(), hb_width, l_map_art_hb_core_thres, l_map_art_hb_width, m_elems, m_land, m_polymapping, RasterMap::MapHeight(), RasterMap::MapWidth(), PolytypeToString(), tole_FieldBoundary, and CfgFloat::value().

 {
   // Make a local copy of the actual map parameters for speed
   // purposes. We are going to use these *a lot*.
   hb_map    = m_land->GetMagicP( 0, 0 );
   hb_width  = m_land->MapWidth();
   hb_height = m_land->MapHeight();
   hb_size   = hb_width * hb_height;
 
   //#ifdef HB_TESTING
   //m_elems[m_polymapping
   //[hb_map[750 + 600*hb_width]]]->SetElementType( tole_Hedges );
   //#endif
 
   // Generate a list of polygon numbers + HB_MAGIC for all hedge elements
   // in our current map.
   hb_FindHedges();
 
   // As one lemming at the cliff edge said to the other: "Let's Go!"
 
   // For every hedge polygon:
   printf("Hedges: %d\n", hb_hedges.size());
   fflush(stdout);
 
   double l_inc = 50.0/((double)hb_hedges.size());
   double l_count = 0.001;
 
   for ( unsigned int i=0; i<hb_hedges.size(); i++ ) {
     l_count += l_inc;
     if ( l_count > 1.0 ) {
       l_count = 0.001;
       printf(".");
       fflush(stdout);
     }
     // Find the enclosing bounding box for our current polygon.
     if ( ! hb_FindBoundingBox( hb_hedges[i] )) {
       // Might want to raise a runtime error upon ending here.
       // The test for hb_FindBoundingBox() fails if we have a polygon
       // without any pixels in the main map!
       continue;
     }
 
     // Move all polygon numbers in our bounding box up! by HB_MAGIC
     // to make room for our 'paint' values in the space below.
     hb_UpPolyNumbers();
 
     hb_ClearPolygon( hb_hedges[i] + HB_MAGIC );
 
     hb_PaintBorder( 0 );
 
     int l_color = 0;
     while ( hb_PaintWhoHasNeighbourColor( l_color,
                       l_color + 1 )) {
       l_color++;
     }
 
     double l_percent = (double)hb_core_pixels/
       ((double)hb_core_pixels+(double)hb_border_pixels);
 
     if ( l_percent > l_map_art_hb_core_thres.value()) {
         // We ought to have at least *some* visible core area
         // within the polygon, so do a simple scan.
 
         // l_color now happens to contain the maximum contour/color value
         // within our current polygon.
         int l_min = (int)((double)l_color * l_map_art_hb_width.value());
         while ( l_color > l_min ) {
             hb_MarkTopFromLocalMax( l_color );
             hb_ResetColorBits();
             l_color--;
         }
     } else {
         // Very thin hedge (1->2 meters),
         // use special border case scan when adding hedge banks.
         hb_MarkTheBresenhamWay();
     }
 
     hb_RestoreHedgeCore( hb_hedges[i] + HB_MAGIC );
 
     // All the previous steps were just preparations.
     // Now do the serious stuff.
     hb_AddNewHedgebanks( hb_hedges[i] );
 
 #ifdef HB_TESTING
     // Sanity check.
     for ( int j=0; j<hb_size; j++ ) {
       if ( m_polymapping[ hb_map[ j ] - HB_MAGIC ] == -1 ) {
     printf("Oh dear!\n");
     exit(1);
       }
     }
 
     char ffname[24];
     sprintf( ffname, "test%02d.ppm", i);
 #endif
 
     // Restore order to the map before continuing.
     hb_DownPolyNumbers();
 
 #ifdef HB_TESTING
     hb_dump_map( 0, hb_width, 0, hb_height, ffname, false );
 #endif
   }
 
   printf("\n");
 #ifdef HB_TESTING
   // Quick reminder.
   for ( unsigned int i=0; i<m_elems.size(); i++ ) {
     if ( m_elems[i]->GetArea() < 0.9 &&
      m_elems[i]->GetElementType() != tole_FieldBoundary ) {
       // Note: Field boundaries have not been scanned yet at this point,
       // so they will have a zero area right here and now.
       printf("Warning: Polygon %6d of type %s came up with area %3.2f!\n",
          m_elems[i]->GetPoly(),
          PolytypeToString( m_elems[i]->GetElementType() ),
          m_elems[i]->GetArea() );
     }
   }
   exit(0);
 #endif
 }

void Landscape::hb_AddNewHedgebanks ( int a_orig_poly_num )

protected

Definition at line 198 of file hedgebanks.cpp.

References hb_GenerateHBPolys(), HB_MAGIC, hb_map, hb_max_x, hb_max_y, hb_min_x, hb_min_y, hb_StripingDist(), and hb_width.

Referenced by hb_Add().

 {
   hb_GenerateHBPolys();
 
   for ( int l_y=hb_min_y; l_y<=hb_max_y; l_y++ ) {
     for ( int l_x=hb_min_x; l_x<=hb_max_x; l_x++ ) {
       int i = l_y*hb_width + l_x;
       int l_val = hb_map[ i ];
       if ( l_val >= 0 && l_val < HB_MAGIC ) {
     hb_map[ i ] = hb_StripingDist() + HB_MAGIC;
     /*
     m_elems[m_polymapping[hb_map[ i ]-HB_MAGIC]]->AddArea( 1.0 );
     m_elems[m_polymapping[hb_map[ i ]-HB_MAGIC]]->m_squares_in_map++;
     m_elems[m_polymapping[a_orig_poly_num]]->AddArea( -1.0 );
     if ( m_elems[m_polymapping[a_orig_poly_num]]->GetArea() < 0.0 ) {
       printf("%d %d !!!\n", l_x, l_y );
       exit(1);
     }
     */
     //m_elems[m_polymapping[a_orig_poly_num]]->m_squares_in_map--;
       }
     }
   }
 }

void Landscape::hb_Cleanup ( void )

protected

void Landscape::hb_ClearPolygon ( int a_poly_num )

protected

Definition at line 413 of file hedgebanks.cpp.

References HB_MAGIC_COLOR, hb_map, hb_max_x, hb_max_y, hb_min_x, hb_min_y, and hb_width.

Referenced by hb_Add().

 {
   // 'Paint' every pixel which belongs to the current polygon with the
   // value HB_MAGIC_COLOR.
   for ( int l_y=hb_min_y; l_y<=hb_max_y; l_y++ ) {
     for ( int l_x=hb_min_x; l_x<=hb_max_x; l_x++ ) {
       int l_coord = l_y*hb_width + l_x;
       if ( hb_map[ l_coord ] == a_poly_num ) {
     hb_map[ l_coord ] = HB_MAGIC_COLOR;
       }
     }
   }
 }

void Landscape::hb_DownPolyNumbers ( void )

protected

Definition at line 715 of file hedgebanks.cpp.

References HB_MAGIC, hb_map, hb_size, hb_width, m_elems, m_polymapping, SV_UINT32, SV_UINT8, and tole_Foobar.

Referenced by hb_Add().

 {
   for ( int i=0; i<hb_size; i++ ) {
     if ( hb_map[ i ] >= HB_MAGIC ) {
       hb_map[ i ] -= HB_MAGIC;
     }
   }
 }

bool Landscape::hb_FindBoundingBox ( int a_poly_num )

protected

Definition at line 243 of file hedgebanks.cpp.

References hb_height, hb_map, hb_max_x, hb_max_y, hb_min_x, hb_min_y, and hb_width.

Referenced by hb_Add().

 {
   hb_min_x = hb_width + 1;
   hb_max_x = -1;
 
   hb_min_y = hb_height + 1;
   hb_max_y = -1;
 
   bool l_found = false;
 
   // Search for every pixel which belongs to the current polygon, and
   // min and max values for x and y. Values are inclusive.
   for ( int l_y=0; l_y<hb_height; l_y++ ) {
     for ( int l_x=0; l_x<hb_width; l_x++ ) {
       if ( hb_map[ l_y*hb_width + l_x ] == a_poly_num ) {
     l_found = true;
     if ( l_x < hb_min_x)
       hb_min_x = l_x;
     else if ( l_x > hb_max_x)
       hb_max_x = l_x;
     if ( l_y < hb_min_y)
       hb_min_y = l_y;
     else if ( l_y > hb_max_y)
       hb_max_y = l_y;
       }
     }
   }
 
   return l_found;
 }

void Landscape::hb_FindHedges ( void )

protected

Definition at line 276 of file hedgebanks.cpp.

References hb_hedges, m_elems, and tole_Hedges.

Referenced by hb_Add().

 {
   for ( unsigned int i=0; i<m_elems.size(); i++ ) {
     if ( tole_Hedges == m_elems[i]->GetElementType() ) {
       hb_hedges.resize( hb_hedges.size() + 1 );
       hb_hedges[ hb_hedges.size() - 1 ] =
     m_elems[i]->GetPoly();
     }
   }
 }

void Landscape::hb_GenerateHBPolys ( void )

protected

Definition at line 180 of file hedgebanks.cpp.

References hb_first_free_poly_num, hb_new_hbs, l_map_art_hb_nums, m_elems, m_polymapping, NewElement(), tole_HedgeBank, and CfgInt::value().

Referenced by hb_AddNewHedgebanks().

 {
   hb_new_hbs.resize( l_map_art_hb_nums.value() );
 
   for ( int i =0; i<l_map_art_hb_nums.value(); i++ ) {
     hb_new_hbs[ i ] = NewElement( tole_HedgeBank );
     hb_new_hbs[ i ]->SetArea( 0.0 );
     hb_new_hbs[ i ]->SetSubType( i );
     m_elems.resize( m_elems.size() + 1 );
     m_elems[ m_elems.size() - 1 ] = hb_new_hbs[ i ];
     m_polymapping[ hb_first_free_poly_num ] =
        (int) m_elems.size() - 1;
     hb_new_hbs[ i ]->SetPoly( hb_first_free_poly_num++ );
   }
 }

bool Landscape::hb_HasNeighbourColor	(	int	a_x,
		int	a_y,
		int	a_neighbour_color
	)

inlineprotected

Definition at line 452 of file hedgebanks.cpp.

References hb_height, hb_map, and hb_width.

Referenced by hb_PaintWhoHasNeighbourColor().

 {
   bool l_neighbour_has_color = false;
   bool loop=false;
 
   do {
     a_x -= 1;
     a_y -= 1;
     if ( a_x >= 0 && a_y >= 0 &&
      hb_map[ a_x + a_y*hb_width ] == a_neighbour_color ) {
       l_neighbour_has_color = true;
       break;
     }
 
     a_x++;
     if ( hb_map[ a_x + a_y*hb_width ] == a_neighbour_color ) {
       l_neighbour_has_color = true;
       break;
     }
 
     a_x++;
     if ( a_x < hb_width &&
      hb_map[ a_x + a_y*hb_width ] == a_neighbour_color ) {
       l_neighbour_has_color = true;
       break;
     }
 
     a_x -= 2;
     a_y += 1;
     if ( a_x >= 0 &&
      hb_map[ a_x + a_y*hb_width ] == a_neighbour_color ) {
       l_neighbour_has_color = true;
       break;
     }
 
     a_x += 2;
     if ( a_x < hb_width &&
      hb_map[ a_x + a_y*hb_width ] == a_neighbour_color ) {
       l_neighbour_has_color = true;
       break;
     }
 
     a_x -= 2;
     a_y += 1;
 
     if ( a_y >= hb_height )
       break;
 
     if ( a_x >= 0 &&
      hb_map[ a_x + a_y*hb_width ] == a_neighbour_color ) {
       l_neighbour_has_color = true;
       break;
     }
 
     a_x++;
     if ( hb_map[ a_x + a_y*hb_width ] == a_neighbour_color ) {
       l_neighbour_has_color = true;
       break;
     }
 
     a_x++;
     if ( a_x < hb_width &&
      hb_map[ a_x + a_y*hb_width ] == a_neighbour_color ) {
       l_neighbour_has_color = true;
       break;
     }
   } while ( loop );  // was while (false) CJT 16-05-06
 
   return l_neighbour_has_color;
 }

bool Landscape::hb_HasOtherNeighbour	(	int	a_x,
		int	a_y
	)

inlineprotected

Definition at line 339 of file hedgebanks.cpp.

References HB_MAGIC, hb_map, hb_MapBorder(), and hb_width.

Referenced by hb_PaintBorder().

 {
   bool l_has_neighbour = false;
   bool loop=false;
 
   // Who said C++ needs the goto statement? ;-)
   do {
     a_x -= 1;
     a_y -= 1;
 
     if ( hb_MapBorder( a_x, a_y ) ||
      hb_map[ a_x + a_y*hb_width ] >= HB_MAGIC ) {
     l_has_neighbour = true;
     break;
     }
 
     a_x++;
     if ( hb_MapBorder( a_x, a_y ) ||
      hb_map[ a_x + a_y*hb_width ] >= HB_MAGIC ) {
       l_has_neighbour = true;
       break;
     }
 
     a_x++;
     if ( hb_MapBorder( a_x, a_y ) ||
      hb_map[ a_x + a_y*hb_width ] >= HB_MAGIC ) {
       l_has_neighbour = true;
       break;
     }
 
     a_x -= 2;
     a_y += 1;
     if ( hb_MapBorder( a_x, a_y ) ||
      hb_map[ a_x + a_y*hb_width ] >= HB_MAGIC ) {
       l_has_neighbour = true;
       break;
     }
 
     a_x += 2;
     if ( hb_MapBorder( a_x, a_y ) ||
      hb_map[ a_x + a_y*hb_width ] >= HB_MAGIC ) {
       l_has_neighbour = true;
       break;
     }
 
     a_x -= 2;
     a_y += 1;
 
     if ( hb_MapBorder( a_x, a_y ) ||
      hb_map[ a_x + a_y*hb_width ] >= HB_MAGIC ) {
       l_has_neighbour = true;
       break;
     }
 
     a_x++;
     if ( hb_MapBorder( a_x, a_y ) ||
      hb_map[ a_x + a_y*hb_width ] >= HB_MAGIC ) {
       l_has_neighbour = true;
       break;
     }
 
     a_x++;
     if ( hb_MapBorder( a_x, a_y ) ||
      hb_map[ a_x + a_y*hb_width ] >= HB_MAGIC ) {
       l_has_neighbour = true;
       break;
     }
   } while ( loop );  // was while (false) CJT 16-05-06
 
   return l_has_neighbour;
 }

bool Landscape::hb_MapBorder	(	int	a_x,
		int	a_y
	)

inlineprotected

Definition at line 325 of file hedgebanks.cpp.

References hb_height, and hb_width.

Referenced by hb_HasOtherNeighbour().

 {
   if ( a_x < 0 ||
        a_y < 0 ||
        a_x >= hb_width ||
        a_y >= hb_height ) {
     return true;
   }
 
   return false;
 }

void Landscape::hb_MarkTheBresenhamWay ( void )

protected

Definition at line 629 of file hedgebanks.cpp.

References HB_MAGIC, hb_map, hb_max_x, hb_max_y, hb_min_x, hb_min_y, hb_width, l_map_art_hb_seg_len, l_map_art_hb_width, and CfgFloat::value().

Referenced by hb_Add().

 {
   double l_hb     = l_map_art_hb_width.value()*10000.0;
   double l_up     = 10000.0 - l_hb;
   bool  l_is_hb  = true;
   double l_length = (double)(random( (int)l_hb )) * 0.0001 *
     l_map_art_hb_seg_len.value();
   double l_hb_remain = 0.0;
   double l_up_remain = 0.0;
 
   for ( int l_y=hb_min_y; l_y<=hb_max_y; l_y++) {
     // Note: The missing update of l_x below is intentional.
     for ( int l_x=hb_min_x; l_x<=hb_max_x; ) {
       int l_coord = l_y*hb_width + l_x;
       if ( hb_map[ l_coord ] < HB_MAGIC ) {
     // 'Painting' with a negative value turns a pixel into
     // hedgebank 'core', ie. hedge!
 
     // Paint segment length with appropriate type.
     if ( l_length >= 1.0 ) {
       if ( l_is_hb ) {
         hb_map[ l_coord ] = 0;
       } else {
         hb_map[ l_coord ] = -1;
       }
       l_length -= 1.0;
       l_x++;
     } else {
       // Change state.
       if ( l_is_hb ) {
         l_is_hb     = false;
         l_hb_remain = l_length;
         l_length = (double)(random( (int)l_up )) * 0.0001 *
           l_map_art_hb_seg_len.value() + l_up_remain;
       } else {
         l_is_hb     = true;
         l_up_remain = l_length;
         l_length = (double)(random( (int)l_hb )) * 0.0001 *
           l_map_art_hb_seg_len.value() + l_hb_remain;
       }
     }
       } else {
     // Pixel not part of the hedge, just update the coordinate.
     l_x++;
       }
     }
   }
 }

void Landscape::hb_MarkTopFromLocalMax ( int a_color )

protected

Definition at line 679 of file hedgebanks.cpp.

References HB_MAGIC_PAINTER_BIT, hb_map, hb_max_x, hb_max_y, hb_MaxUnpaintedNegNeighbour(), hb_min_x, hb_min_y, and hb_width.

Referenced by hb_Add().

 {
   // Sweep through the map. If we find a pixel, which has a value
   // equal to a_color and *not* a negative neighbour, then mark it as
   // negative with an absolute value equal to the number of steps from
   // here and out to the center/perimeter polygons border, calculated
   // as the given percentage.
 
   // If one or more negative numbers are found among the neighbours,
   // some that were not marked during this round, then assign a
   // negative value equal to the minimum found plus one.
 
   for ( int l_y=hb_min_y; l_y<=hb_max_y; l_y++ ) {
     for ( int l_x=hb_min_x; l_x<=hb_max_x; l_x++ ) {
       int l_coord = l_y*hb_width + l_x;
       int l_max;
       if ( hb_map[ l_coord ] == a_color ) {
     l_max = hb_MaxUnpaintedNegNeighbour( l_x, l_y );
     if ( l_max < 0 ) {
       if ( ++l_max < 0 ) {
         hb_map[ l_coord ]  = l_max;
       } else {
         // l_max was precisely -1
         hb_map[ l_coord ]  = -1;
       }
     } else {
       // We are a local maxima.
       hb_map[ l_coord ]  = -a_color;
     }
     hb_map[ l_coord ] ^= HB_MAGIC_PAINTER_BIT;
       }
     }
   }
 }

int Landscape::hb_MaxUnpaintedNegNeighbour	(	int	a_x,
		int	a_y
	)

inlineprotected

Definition at line 548 of file hedgebanks.cpp.

References hb_height, HB_MAGIC_PAINTER_BIT, hb_map, and hb_width.

Referenced by hb_MarkTopFromLocalMax().

 {
   int l_max_neg = 0;
   int l_val;
   bool loop=false; // This is just to avoid the warning about constant expression if we use: do {...} while (false)
 
   do {
     a_x -= 1;
     a_y -= 1;
     if ( a_x >= 0 && a_y >= 0 ) {
       l_val = hb_map[ a_x + a_y*hb_width ];
       if ( l_val < l_max_neg && (l_val & HB_MAGIC_PAINTER_BIT)) {
     l_max_neg = l_val;
       }
     }
 
     a_x++;
     l_val = hb_map[ a_x + a_y*hb_width ];
     if ( l_val < l_max_neg && (l_val & HB_MAGIC_PAINTER_BIT)) {
       l_max_neg = l_val;
     }
 
     a_x++;
     if ( a_x < hb_width ) {
       l_val = hb_map[ a_x + a_y*hb_width ];
       if ( l_val < l_max_neg && (l_val & HB_MAGIC_PAINTER_BIT)) {
     l_max_neg = l_val;
       }
     }
 
     a_x -= 2;
     a_y += 1;
     if ( a_x >= 0 ) {
       l_val = hb_map[ a_x + a_y*hb_width ];
       if ( l_val < l_max_neg && (l_val & HB_MAGIC_PAINTER_BIT)) {
     l_max_neg = l_val;
       }
     }
 
     a_x += 2;
     if ( a_x < hb_width ) {
       l_val = hb_map[ a_x + a_y*hb_width ];
       if ( l_val < l_max_neg && (l_val & HB_MAGIC_PAINTER_BIT)) {
     l_max_neg = l_val;
       }
     }
 
     a_x -= 2;
     a_y += 1;
 
     if ( a_y >= hb_height )
       break;
 
     if ( a_x >= 0 ) {
       l_val = hb_map[ a_x + a_y*hb_width ];
       if ( l_val < l_max_neg && (l_val & HB_MAGIC_PAINTER_BIT)) {
     l_max_neg = l_val;
       }
     }
 
     a_x++;
     l_val = hb_map[ a_x + a_y*hb_width ];
     if ( l_val < l_max_neg && (l_val & HB_MAGIC_PAINTER_BIT)) {
       l_max_neg = l_val;
     }
 
     a_x++;
     if ( a_x < hb_width ) {
       l_val = hb_map[ a_x + a_y*hb_width ];
       if ( l_val < l_max_neg && (l_val & HB_MAGIC_PAINTER_BIT)) {
     l_max_neg = l_val;
       }
     }
   } while ( loop );
 
   return l_max_neg;
 }

void Landscape::hb_PaintBorder ( int a_color )

protected

Definition at line 429 of file hedgebanks.cpp.

References hb_border_pixels, hb_core_pixels, hb_HasOtherNeighbour(), HB_MAGIC_COLOR, hb_map, hb_max_x, hb_max_y, hb_min_x, hb_min_y, and hb_width.

Referenced by hb_Add().

 {
   hb_border_pixels = 0;
   hb_core_pixels   = 0;
   // Paint every pixel which belongs to the current polygon, and which
   // does have a neighbour *not* equal to HB_MAGIC_COLOR (our marker value).
   for ( int l_y=hb_min_y; l_y<=hb_max_y; l_y++ ) {
     for ( int l_x=hb_min_x; l_x<=hb_max_x; l_x++ ) {
       int l_coord = l_y*hb_width + l_x;
       if ( hb_map[ l_coord ] == HB_MAGIC_COLOR ) {
         if ( hb_HasOtherNeighbour( l_x, l_y )) {
           hb_map[ l_coord ] = a_color;
           hb_border_pixels++;
         } else {
           hb_core_pixels++;
         }
       }
     }
   }
 }

bool Landscape::hb_PaintWhoHasNeighbourColor	(	int	a_neighbour_color,
		int	a_new_color
	)

protected

Definition at line 526 of file hedgebanks.cpp.

References hb_HasNeighbourColor(), HB_MAGIC_COLOR, hb_map, hb_max_x, hb_max_y, hb_min_x, hb_min_y, and hb_width.

Referenced by hb_Add().

 {
   // Paint every pixel which belongs to the current polygon, and which
   // has a neighbour with a color equal to a_neighbour_color.
 
   bool l_at_least_one = false;
   for ( int l_y=hb_min_y; l_y<=hb_max_y; l_y++ ) {
     for ( int l_x=hb_min_x; l_x<=hb_max_x; l_x++ ) {
       if ( hb_map[l_y*hb_width + l_x] == HB_MAGIC_COLOR &&
        hb_HasNeighbourColor( l_x, l_y, a_neighbour_color )) {
     hb_map[l_y*hb_width + l_x] = a_new_color;
     l_at_least_one = true;
       }
     }
   }
 
   return l_at_least_one;
 }

void Landscape::hb_ResetColorBits ( void )

protected

Definition at line 298 of file hedgebanks.cpp.

References HB_MAGIC_PAINTER_BIT, hb_map, hb_max_x, hb_max_y, hb_min_x, hb_min_y, and hb_width.

Referenced by hb_Add().

 {
   for ( int l_y=hb_min_y; l_y<=hb_max_y; l_y++ ) {
     for ( int l_x=hb_min_x; l_x<=hb_max_x; l_x++ ) {
       int l_coord = l_y*hb_width + l_x;
       if ( hb_map[l_coord] < 0 )
     hb_map[l_coord] |= HB_MAGIC_PAINTER_BIT;
     }
   }
 }

void Landscape::hb_RestoreHedgeCore ( int a_orig_poly_number )

protected

Definition at line 311 of file hedgebanks.cpp.

References hb_map, hb_max_x, hb_max_y, hb_min_x, hb_min_y, and hb_width.

Referenced by hb_Add().

 {
   for ( int l_y=hb_min_y; l_y<=hb_max_y; l_y++ ) {
     for ( int l_x=hb_min_x; l_x<=hb_max_x; l_x++ ) {
       int l_coord = l_y*hb_width + l_x;
       if (  hb_map[l_coord] < 0 ) {
         hb_map[l_coord] = a_orig_poly_number;
       }
     }
   }
 }

int Landscape::hb_StripingDist ( void )

protected

Definition at line 225 of file hedgebanks.cpp.

References LE::GetPoly(), hb_new_hbs, l_map_art_hb_nums, l_map_art_hb_tran_prob, and CfgInt::value().

Referenced by hb_AddNewHedgebanks().

 {
   // Striping distribution function for the new hedgebanks.
   static LE* l_curr_ele = NULL;
 
   if ( !l_curr_ele ) {
     l_curr_ele = hb_new_hbs[ random( l_map_art_hb_nums.value()) ];
     return l_curr_ele->GetPoly();
   }
 
   if ( random(100) < l_map_art_hb_tran_prob.value() )
     l_curr_ele = hb_new_hbs[ random( l_map_art_hb_nums.value()) ];
 
   return l_curr_ele->GetPoly();
 }

void Landscape::hb_UpPolyNumbers ( void )

protected

Definition at line 289 of file hedgebanks.cpp.

References HB_MAGIC, hb_map, and hb_size.

Referenced by hb_Add().

 {
   for ( int i=0; i<hb_size; i++ ) {
     hb_map[ i ] += HB_MAGIC;
   }
 }

int Landscape::HowManyPonds ( )

inline

Returns the number of ponds in the landscape.

Definition at line 315 of file landscape.h.

315 { return int(m_PondIndexList.size()); }

Landscape::m_PondIndexList

vector< int > m_PondIndexList

List of pond indexes.

Definition: landscape.h:175

void Landscape::IncTreatCounter ( int a_treat )

Definition at line 3339 of file Landscape.cpp.

References g_msg, last_treatment, MapErrorMsg::Warn(), and WARN_BUG.

Referenced by LE::SetLastTreatment().

                                            {
     if (a_treat < 0 || a_treat >= last_treatment) {
         char errornum[20];
         sprintf(errornum, "%d", a_treat);
         g_msg->Warn(WARN_BUG, "Landscape::IncTreatCounter(): Index"" out of range!", errornum);
         exit(1);
     }
     m_treatment_counts[a_treat] ++;
 }

bool Landscape::IsFieldType ( TTypesOfLandscapeElement a_tole )

inline

Definition at line 676 of file landscape.h.

References tole_Field, tole_Orchard, tole_PermanentSetaside, tole_PermPasture, tole_PermPastureLowYield, tole_PermPastureTussocky, tole_PermPastureTussockyWet, tole_Vildtager, tole_WoodyEnergyCrop, and tole_YoungForest.

                                                     {
       if ((a_tole == tole_Field)
           || (a_tole == tole_Orchard)
           || (a_tole == tole_PermanentSetaside)
           || (a_tole == tole_PermPasture)
           || (a_tole == tole_PermPastureLowYield)
           || (a_tole == tole_PermPastureTussocky)
           || (a_tole == tole_PermPastureTussockyWet)
           || (a_tole == tole_Vildtager)
           || (a_tole == tole_YoungForest)
           || (a_tole == tole_WoodyEnergyCrop)
           ) return true;
       return false;
   }

int Landscape::LineHighTest	(	int	a_cx,
		int	a_cy,
		double	a_offsetx,
		double	a_offsety
	)

inline

Provides a measure of the shortest distance in using a vector from a_cx,a_cy unitl tall obstacles are encountered in both +ve & -ve directions.

Returns: d1 is the distance from cx,cy to the obstruction. Runs out a line along a vector set by offsetx & offsety, from cx & cy until it meets too many high elements.

Will only stop when two consecutive squares return 'high'.

The criteria for threat or non-open are based on geese and include tall objects and roads

Definition at line 439 of file Landscape.cpp.

References tole_HedgeBank, tole_LargeRoad, and tole_SmallRoad.

 {
     int d1=-1;
     int counter = 1;
     bool found = false;
     while (!found)
     {
         int x = (int) (a_cx + a_offsetx * counter);
         int y = (int) (a_cy + a_offsety * counter);
         if (x<1 || x >= (m_width-2) || y<1 || y >= (m_height-2)) return counter;
         TTypesOfLandscapeElement tole = this->SupplyElementType(x,y);
         if ((tole == tole_LargeRoad) || (tole == tole_SmallRoad) || (tole == tole_HedgeBank)) return counter;
         if (SupplyLEHigh(x,y))
         {
             x = (int) (a_cx + a_offsetx * (counter+1));
             y = (int) (a_cy + a_offsety * (counter+1));
             if (SupplyLEHigh(x,y)) found = true;
             d1=counter;
         }
         counter++;
     }
     return d1;
 }

int Landscape::MagicMapP2PolyRef ( int a_magic )

inline

Definition at line 1442 of file landscape.h.

 {
   return m_elems[ a_magic ]->GetPoly();
 }

void Landscape::MakeCluster ( void )

protected

Reset all polygons natural grazing level to zero.

Inc volegrazing at x,y Get volegrazing at x,y Calculate all vole grazing densities

void Landscape::ModifyPolyRef ( int * )

protected

LE * Landscape::NewElement ( TTypesOfLandscapeElement a_type )

protected

Definition at line 3455 of file Landscape.cpp.

References g_msg, LE::SetALMaSSEleType(), LE::SetElementType(), tole_ActivePit, tole_AmenityGrass, tole_BareRock, tole_BeetleBank, tole_Building, tole_BuiltUpWithParkland, tole_Carpark, tole_Chameleon, tole_Churchyard, tole_Coast, tole_ConiferousForest, tole_Copse, tole_DeciduousForest, tole_Field, tole_FieldBoundary, tole_FishFarm, tole_Freshwater, tole_Garden, tole_Heath, tole_HedgeBank, tole_Hedges, tole_HeritageSite, tole_IndividualTree, tole_LargeRoad, tole_Marsh, tole_MetalledPath, tole_Missing, tole_MixedForest, tole_MownGrass, tole_NaturalGrassDry, tole_NaturalGrassWet, tole_Orchard, tole_OrchardBand, tole_Parkland, tole_PermanentSetaside, tole_PermPasture, tole_PermPastureLowYield, tole_PermPastureTussocky, tole_PitDisused, tole_PlantNursery, tole_Pond, tole_Pylon, tole_Railway, tole_River, tole_RiversidePlants, tole_RiversideTrees, tole_RoadsideSlope, tole_RoadsideVerge, tole_Saltmarsh, tole_Saltwater, tole_SandDune, tole_Scrub, tole_SmallRoad, tole_StoneWall, tole_Stream, tole_Track, tole_UnsprayedFieldMargin, tole_UrbanNoVeg, tole_UrbanPark, tole_Vildtager, tole_Wasteland, tole_WindTurbine, tole_WoodlandMargin, tole_WoodyEnergyCrop, tole_YoungForest, MapErrorMsg::Warn(), and WARN_FILE.

Referenced by hb_GenerateHBPolys().

                                                           {
     LE * elem;
     static char error_num[20];
 
     switch (a_type) {
     case tole_Hedges:
         elem = new Hedges;
         break;
     case tole_HedgeBank:
         elem = new HedgeBank;
         elem->SetALMaSSEleType(140);
         break;
     case tole_BeetleBank:
         elem = new BeetleBank;
         elem->SetALMaSSEleType(141);
         break;
     case tole_RoadsideVerge:
         elem = new RoadsideVerge;
         break;
     case tole_Railway:
         elem = new Railway;
         break;
     case tole_FieldBoundary:
         elem = new FieldBoundary;
         elem->SetALMaSSEleType(160);
         break;
     case tole_Marsh:
         elem = new Marsh;
         break;
     case tole_Orchard:
         elem = new Orchard;
         break;
     case tole_OrchardBand:
         elem = new OrchardBand;
         break;
     case tole_MownGrass:
         elem = new MownGrass;
         break;
     case tole_Heath:
         elem = new Heath;
         break;
     case tole_Scrub:
         elem = new Scrub;
         break;
     case tole_Field:
         elem = new Field;
         break;
     case tole_PermanentSetaside:
         elem = new PermanentSetaside;
         break;
     case tole_PermPasture:
         elem = new PermPasture;
         break;
     case tole_PermPastureLowYield:
         elem = new PermPastureLowYield;
         break;
     case tole_PermPastureTussocky:
         elem = new PermPastureTussocky;
         break;
     case tole_NaturalGrassDry:
         elem = new NaturalGrassDry;
         break;
     case tole_RiversidePlants:
         elem = new RiversidePlants;
         break;
     case tole_PitDisused:
         elem = new PitDisused;
         break;
     case tole_RiversideTrees:
         elem = new RiversideTrees;
         break;
     case tole_DeciduousForest:
         elem = new DeciduousForest;
         break;
     case tole_MixedForest:
         elem = new MixedForest;
         break;
     case tole_YoungForest:
         elem = new YoungForest;
         break;
     case tole_ConiferousForest:
         elem = new ConiferousForest;
         break;
     case tole_StoneWall:
         elem = new StoneWall;
         break;
     case tole_Garden:
         elem = new Garden;
         break;
     case tole_Track:
         elem = new Track;
         break;
     case tole_SmallRoad:
         elem = new SmallRoad;
         break;
     case tole_LargeRoad:
         elem = new LargeRoad;
         break;
     case tole_Building:
         elem = new Building;
         break;
     case tole_ActivePit:
         elem = new ActivePit;
         break;
     case tole_Freshwater:
         elem = new Freshwater;
         break;
     case tole_Pond:
         elem = new Pond;
         break;
     case tole_River:
         elem = new River;
         break;
     case tole_Saltwater:
         elem = new Saltwater;
         break;
     case tole_Coast:
         elem = new Coast;
         break;
     case tole_BareRock:
         elem = new BareRock;
         break;
     case tole_AmenityGrass:
         elem = new AmenityGrass;
         break;
     case tole_Parkland:
         elem = new Parkland;
         break;
     case tole_UrbanNoVeg:
         elem = new UrbanNoVeg;
         break;
     case tole_UrbanPark:
         elem = new UrbanPark;
         break;
     case tole_BuiltUpWithParkland:
         elem = new BuiltUpWithParkland;
         break;
     case tole_SandDune:
         elem = new SandDune;
         break;
     case tole_Copse:
         elem = new Copse;
         break;
     case tole_RoadsideSlope:
         elem = new RoadsideSlope;
         break;
     case tole_MetalledPath:
         elem = new MetalledPath;
         break;
     case tole_Carpark:
         elem = new Carpark;
         break;
     case tole_Churchyard:
         elem = new Churchyard;
         break;
     case tole_NaturalGrassWet:
         elem = new NaturalGrassWet;
         break;
     case tole_Saltmarsh:
         elem = new Saltmarsh;
         break;
     case tole_Stream:
         elem = new Stream;
         break;
     case tole_HeritageSite:
         elem = new HeritageSite;
         break;
     case tole_UnsprayedFieldMargin:
         elem = new UnsprayedFieldMargin;
         elem->SetALMaSSEleType(31);
         break;
     case tole_Wasteland:
         elem = new Wasteland;
         break;
     case tole_IndividualTree:
         elem = new IndividualTree;
         break;
     case tole_PlantNursery:
         elem = new PlantNursery;
         break;
     case tole_Vildtager:
         elem = new Vildtager;
         break;
     case tole_WindTurbine:
         elem = new WindTurbine;
         break;
     case tole_WoodyEnergyCrop:
         elem = new WoodyEnergyCrop;
         break;
     case tole_WoodlandMargin:
         elem = new WoodlandMargin;
         break;
     case tole_Pylon:
         elem = new Pylon;
         break;
     case tole_FishFarm:
         elem = new FishFarm;
         break;
     case tole_Missing:
         elem = new LE; // These should never be actually used.
         break;
     case tole_Chameleon:
         elem = new ChameleonLE;
         break;
     default:
         sprintf(error_num, "%d", a_type);
         g_msg->Warn(WARN_FILE, "Landscape::NewElement(): Unknown landscape element requested:", error_num);
         exit(1);
     } //switch
 
     elem->SetElementType(a_type);
 
     return elem;
 }

void Landscape::PolysDump ( const char * a_filename )

protected

Definition at line 1612 of file Landscape.cpp.

References g_msg, MapErrorMsg::Warn(), and WARN_FILE.

 {
     ofstream outf(a_filename, ios::out);
     int l_num_polys = 0;
 
     if (!outf.is_open()) {
         g_msg->Warn(WARN_FILE, "Landscape::PolysDump(): Unable to open file", a_filename);
         exit(1);
     }
 
     // Count up number if active polygons in our list.
     unsigned sz = (unsigned)m_elems.size();
     for (unsigned int i = 0; i < sz; i++) {
         if (m_elems[i]->GetMapValid())
             l_num_polys++;
     }
 
     outf << l_num_polys << endl;
     outf << "PolyType" << '\t' << "PolyRefNum" << '\t' << "Area" << '\t' << "FarmRef" << '\t' << "UnSprayedMarginRef" << '\t' << "SoilType" << '\t' << "Openness" << '\t' << "CentroidX" << '\t' << "CentroidY" << endl;
 
     /*
     if ( l_map_renumberpolys.value() )
     {
     RenumberPolys( true );
     }
     */
     // Now we can output the file
     for (unsigned int i = 0; i < m_elems.size(); i++)
     {
         if (m_elems[i]->GetMapValid())
         {
             outf << m_elems[i]->GetALMaSSEleType() << '\t' << m_elems[i]->GetPoly() << '\t' << m_elems[i]->GetArea() << '\t' <<
                 m_elems[i]->GetOwnerFile() << '\t' << m_elems[i]->GetUnsprayedMarginPolyRef() << '\t' << m_elems[i]->GetSoilType() << '\t' << m_elems[i]->GetOpenness()
                 << '\t' << m_elems[i]->GetCentroidX() << '\t' << m_elems[i]->GetCentroidY() << endl;
         }
     }
     outf.close();
 }

void Landscape::PolysRemoveInvalid ( void )

protected

PolysValidate or ChangeMapMapping must be called after this method

Definition at line 1584 of file Landscape.cpp.

 {
   vector < LE * > l_temp;
   cout << "Tidying up the polygon map in PolysRemoveInvalid" << endl;
   unsigned int sz= (int) m_elems.size();
   for ( unsigned int i = 0; i < sz; i++ ) {
     if ( m_elems[ i ]->GetMapValid() ) {
       unsigned int j =  (int) l_temp.size();
       l_temp.resize( j + 1 );
       l_temp[ j ] = m_elems[ i ];
     } else {
         // cout << "Deleted m_elems index:" << m_polymapping[ m_elems[ i ]->GetPoly() ] << " Polynumber :" << m_elems[ i ]->GetPoly() << BackTranslateEleTypes(m_elems[ i ]->GetElementType()) << endl;
         m_polymapping[ m_elems[ i ]->GetPoly() ] = -1;
       delete m_elems[ i ];
     }
   }
 
   for ( unsigned int i = 0; i < l_temp.size(); i++ ) {
     m_elems[ i ] = l_temp[ i ];
   }
   m_elems.resize( l_temp.size() );
   RebuildPolyMapping();
 }

void Landscape::PolysRenumber ( void )

protected

Definition at line 1871 of file Landscape.cpp.

References g_msg, MapErrorMsg::Warn(), and WARN_FILE.

 {
     cout << "In Landscape::Landscape() Polygon renumber." << endl;
     for (unsigned int i = 0; i < m_elems.size(); i++)
     {
         // Need to reset the poly number
         int index = m_elems[i]->GetMapIndex(); // This is the number currently in the map matrix
         m_elems[i]->SetPoly(index); // The map index and the polygon number are now one and the same
         m_polymapping[index] = i; // The polymapping is now linked via index to the m_elems index (i)
     }
     m_LargestPolyNumUsed = (int) m_elems.size()-1;
     g_msg->Warn(WARN_FILE, "Landscape::Landscape() ""Map to be dumped due to polygon renumber", "");
 }

void Landscape::PolysValidate ( bool a_exit_on_invalid )

protected

Definition at line 1557 of file Landscape.cpp.

References g_msg, MapErrorMsg::Warn(), and WARN_FILE.

                                                       {
    // First loop just sets the MapValid as false (and checks for a major screw-up if this elemenent does not exist even in the list
   for ( unsigned int i = 0; i < m_elems.size(); i++ ) {
     m_elems[ i ]->SetMapValid( false );
     if ( m_polymapping[ m_elems[ i ]->GetPoly() ] == -1 ) {
       char l_err[ 20 ];
       sprintf( l_err, "%d", m_elems[ i ]->GetPoly() );
       g_msg->Warn( WARN_FILE, "Landscape::PolysValidate(): Invalid polymapping ", l_err );
       exit( 1 );
     }
   }
   // Now go through the whole map and for each polygon found set MapValid as true.
   SetPolyMaxMinExtents();
 
   if ( a_exit_on_invalid ) {
     for ( unsigned int i = 0; i < m_elems.size(); i++ ) {
       if ( !m_elems[ i ]->GetMapValid() ) {
         char l_err[ 20 ];
         sprintf( l_err, "%d", m_elems[ i ]->GetPoly() );
         g_msg->Warn( WARN_FILE, "Landscape::PolysValidate(): Invalid polygon ", l_err );
         exit( 0 );
       }
     }
   }
 }

std::string Landscape::PolytypeToString ( TTypesOfLandscapeElement a_le_type )

Definition at line 3801 of file Landscape.cpp.

References g_msg, tole_ActivePit, tole_AmenityGrass, tole_BareRock, tole_BeetleBank, tole_Building, tole_BuiltUpWithParkland, tole_Carpark, tole_Churchyard, tole_Coast, tole_ConiferousForest, tole_Copse, tole_DeciduousForest, tole_Field, tole_FieldBoundary, tole_FishFarm, tole_Foobar, tole_Freshwater, tole_Garden, tole_Heath, tole_HedgeBank, tole_Hedges, tole_HeritageSite, tole_IndividualTree, tole_LargeRoad, tole_Marsh, tole_MetalledPath, tole_MixedForest, tole_MownGrass, tole_NaturalGrassDry, tole_NaturalGrassWet, tole_Orchard, tole_OrchardBand, tole_Parkland, tole_PermanentSetaside, tole_PermPasture, tole_PermPastureLowYield, tole_PermPastureTussocky, tole_PitDisused, tole_PlantNursery, tole_Pond, tole_Pylon, tole_Railway, tole_River, tole_RiversidePlants, tole_RiversideTrees, tole_RoadsideSlope, tole_RoadsideVerge, tole_Saltmarsh, tole_Saltwater, tole_SandDune, tole_Scrub, tole_SmallRoad, tole_StoneWall, tole_Stream, tole_Track, tole_UnknownGrass, tole_UnsprayedFieldMargin, tole_UrbanNoVeg, tole_UrbanPark, tole_Vildtager, tole_Wasteland, tole_WindTurbine, tole_WoodlandMargin, tole_WoodyEnergyCrop, tole_YoungForest, MapErrorMsg::Warn(), and WARN_FILE.

Referenced by hb_Add().

                                                                         {
     char error_num[20];
 
     switch (a_le_type) {
     case tole_Hedges:
         return "                Hedge";
     case tole_RoadsideVerge:
         return "       Roadside Verge";
     case tole_Railway:
         return "              Railway";
     case tole_FieldBoundary:
         return "       Field Boundary";
     case tole_Marsh:
         return "                Marsh";
     case tole_Scrub:
         return "                Scrub";
     case tole_Field:
         return "                Field";
     case tole_PermPastureTussocky:
         return " PermPastureTussocky";
     case tole_PermanentSetaside:
         return "   Permanent Setaside";
     case tole_PermPasture:
         return "    Permanent Pasture";
     case tole_PermPastureLowYield:
         return " PermPastureLowYield";
     case tole_NaturalGrassDry:
         return "        Natural Grass";
     case tole_NaturalGrassWet:
         return "    Natural Grass Wet";
     case tole_RiversidePlants:
         return "     Riverside Plants";
     case tole_PitDisused:
         return "          Pit Disused";
     case tole_RiversideTrees:
         return "      Riverside Trees";
     case tole_DeciduousForest:
         return "     Deciduous Forest";
     case tole_MixedForest:
         return "         Mixed Forest";
     case tole_ConiferousForest:
         return "    Coniferous Forest";
     case tole_YoungForest:
         return "         Young Forest";
     case tole_StoneWall:
         return "           Stone Wall";
     case tole_Garden:
         return "               Garden";
     case tole_Track:
         return "                Track";
     case tole_SmallRoad:
         return "           Small Road";
     case tole_LargeRoad:
         return "           Large Road";
     case tole_Building:
         return "             Building";
     case tole_ActivePit:
         return "           Active Pit";
     case tole_Pond:
         return "                 Pond";
     case tole_Freshwater:
         return "          Fresh Water";
     case tole_River:
         return "                River";
     case tole_Saltwater:
         return "            Saltwater";
     case tole_Coast:
         return "                Coast";
     case tole_BareRock:
         return "            Bare Rock";
     case tole_HedgeBank:
         return "            Hedgebank";
     case tole_Heath:
         return "                Heath";
     case tole_Orchard:
         return "              Orchard";
     case tole_OrchardBand:
         return "         Orchard Band";
     case tole_MownGrass:
         return "           Mown Grass";
     case tole_UnsprayedFieldMargin:
         return " UnsprayedFieldMargin";
     case tole_AmenityGrass:
         return "         AmenityGrass";
     case tole_Parkland:
         return "             Parkland";
     case tole_UrbanNoVeg:
         return "           UrbanNoVeg";
     case tole_UrbanPark:
         return "            UrbanPark";
     case tole_BuiltUpWithParkland:
         return "  BuiltUpWithParkland";
     case tole_SandDune:
         return "             SandDune";
     case tole_Copse:
         return "                Copse";
     case tole_RoadsideSlope:
         return "        RoadsideSlope";
     case tole_MetalledPath:
         return "         MetalledPath";
     case tole_Carpark:
         return "             Carpark";
     case tole_Churchyard:
         return "          Churchyard";
     case tole_Saltmarsh:
         return "           Saltmarsh";
     case tole_Stream:
         return "              Stream";
     case tole_HeritageSite:
         return "        HeritageSite";
     case tole_BeetleBank:  //141
         return "         Beetle Bank";
     case tole_UnknownGrass:
         return "       Unknown Grass";
     case tole_Wasteland:
         return " Waste/Building Land";
     case tole_IndividualTree:
         return "      IndividualTree";
     case tole_PlantNursery:
         return "        PlantNursery";
     case tole_Vildtager:
         return "           Vildtager";
     case tole_WindTurbine:
         return "         WindTurbine";
     case tole_WoodyEnergyCrop:
         return "     WoodyEnergyCrop";
     case tole_WoodlandMargin:
         return "      WoodlandMargin";
     case tole_Pylon:
         return "               Pylon";
     case tole_FishFarm:
         return "            FishFarm";
     case tole_Foobar:
     default:
         sprintf(error_num, "%d", a_le_type);
         g_msg->Warn(WARN_FILE, "Landscape::PolytypeToString(): Unknown event type:", error_num);
         exit(1);
     }
 }

APoint Landscape::RandomLocation ( void )

protected

void Landscape::ReadInput	(	int *	,
		int *	,
		int *	,
		APoint *
	)

protected

void Landscape::ReadOpenness ( void )

Reads openness values from a standard input file for all polygons.

void Landscape::ReadPolys ( const char * a_polyfile )

protected

void Landscape::ReadPolys2 ( const char * a_polyfile )

protected

reads in polygon information. Version 2 including centroid and openness information

The polygon file consists of 9 columns:

Polygon Number 2. Type 3. Area as a double 4. Owner (-1 = now owner), 5- -1 or unsprayed margin polynum
, column 6 is soil type (-1 if not used), column 7 is the polygon openness score (-1 if unset), 8 is the x-coordinate of the centroid, and 9 is the y-coordinate of the centroid. If either of these centroid coords are -1, then the centroid calculation will be forced.
If this is to be used then cfg_map_usesoiltypes needs to be set as true (default true).

As of December 2014 there is a header row of information to be skipped here

As of July 2013 we have the need to use really big maps, hence polygon reference numbers need to be kept within reasonable bounds. It is now a requirement that any polyref number is < twice the total number of polygons in the file.

This is a quick way to replace one type with another for some simulations, polygon type 150 therefore has some special uses

With the polygons renumbered, we can safely set the hb_first_free_poly_num to the number of polygons we have.

Definition at line 1701 of file Landscape.cpp.

References g_letype, g_map_le_border_chance, g_map_le_borders, g_map_le_unsprayedmargins, g_map_le_unsprayedmargins_chance, g_msg, LE::GetElementType(), l_map_chameleon_replace_num, LE::SetALMaSSEleType(), LE::SetArea(), LE::SetBorder(), LE::SetCentroid(), LE::SetOpenness(), LE::SetPoly(), LE::SetSoilType(), LE::SetUnsprayedMarginPolyRef(), tole_Field, tole_Missing, tole_Orchard, tole_PermanentSetaside, tole_PermPasture, tole_PermPastureLowYield, tole_PermPastureTussocky, tole_PlantNursery, tole_Vildtager, tole_WoodyEnergyCrop, tole_YoungForest, LE_TypeClass::TranslateEleTypes(), CfgInt::value(), CfgBool::value(), MapErrorMsg::Warn(), and WARN_FILE.

 {
     // Need to figure out if the farms are already renumbered - as the Farm manager
     bool farmsrenum = m_FarmManager->GetIsRenumbered();
 
     int NoPolygons;
     string rubbish = ""; //put here the names of the parameters;
     ifstream ifile(a_polyfile);
     if (!ifile.is_open()) {
         g_msg->Warn(WARN_FILE, "Landscape::ReadPolys(): Unable to open file", a_polyfile);
         std::exit(1);
     }
     char error_num[20];
     // First read the number of polygons 
     ifile >> NoPolygons;
     m_elems.resize(NoPolygons);
     for (int i = 0; i < 9; i++){ ifile >> rubbish; }
     int np = NoPolygons;
     if (NoPolygons < 10000) np = 10000; // this is just to cope with old maps with < 10000 polygons that do not follow the rules for new maps
     m_polymapping = (int *)malloc(sizeof(int)* (np * 2));
     // Test if we have the memory to do this
     if (m_polymapping == NULL) 
     {
         g_msg->Warn(WARN_FILE, "Landscape::ReadPolys(): Out of memory!", "");
         std::exit(1);
     }
 
     // Set all mappings to unused.
     for (int i = 0; i < np * 2; i++) {
         m_polymapping[i] = -1;
     }
 
     int ElemIndex = 0;
 
     for (int x = 0; x < NoPolygons; x++)
     {
         int PolyNum, Owner, PolyType, RealPolyType, URef, SoilType, openness, Centroid_x, Centroid_y;
         TTypesOfLandscapeElement Type;
         float Area;
         ifile >> PolyType >> PolyNum >> Area >> Owner >> URef >> SoilType >> openness >> Centroid_x >> Centroid_y;
         // Here we make some tests to check input validity
         if ((SoilType > 16) || (PolyNum<0))
         {
             std::sprintf(error_num, "%d", NoPolygons);
                 g_msg->Warn(WARN_FILE, "Landscape::ReadPolys(): Polygon file empty before "
                     "reading number of specified polygons (old polygon file format?):", error_num);
                 std::exit(1);
         }
 
         // Owner is the farm number or -1. If farms have not been renumbered then this needs mapped to the index in the list of farms.
         // Because we create this sequentially in Farm.cpp we have a constant index.
         if ((-1 != Owner) && !farmsrenum)
         {
             // Need to replace the Owner with the new renumbered ref.
             Owner = m_FarmManager->GetRenumberedFarmRef(Owner);
         }
 
         RealPolyType = PolyType;
         if (PolyType == 150) 
         {
             PolyType = l_map_chameleon_replace_num.value();
         }
 
         Type = g_letype->TranslateEleTypes(PolyType);
         if (Type == tole_Missing)
         {
             m_DoMissingPolygonsManipulations = true;
         }
         if (-1 == m_polymapping[PolyNum])
         {
             // First time we have encountered this polygon number.
             // Borders are not mapped in this list.
             m_polymapping[PolyNum] = ElemIndex;
             LE * newland = NewElement(Type);
             m_elems[ElemIndex++] = newland;
             newland->SetPoly(PolyNum);
             newland->SetArea(floor(0.5 + Area));
             newland->SetALMaSSEleType(RealPolyType);
             newland->SetSoilType(SoilType);
             newland->SetUnsprayedMarginPolyRef(URef);
             newland->SetCentroid(Centroid_x,Centroid_y);
             newland->SetOpenness(openness);
             // Just for fun, or maybe because we might need it later, remember the actual largest polynum used
             if (PolyNum>m_LargestPolyNumUsed) m_LargestPolyNumUsed = PolyNum;
             // Now set any centroid or openness recalcuation flags
             if ((Centroid_x < 0) || (Centroid_y < 0)) m_NeedCentroidCalculation= true;
             if (openness < 0) m_NeedOpennessCalculation = true;
             // Two types of possible errors: Landscape element that is a field,
             // but doesn't belong to a farm, or a farm element not of type field.
             // Check for both cases.
             if (-1 == Owner && (Type == tole_Field || Type == tole_YoungForest || Type == tole_Orchard || Type == tole_PermPastureTussocky || Type == tole_PermPasture || Type == tole_PermanentSetaside || Type == tole_PermPastureLowYield || Type == tole_WoodyEnergyCrop || Type == tole_Vildtager || Type == tole_PlantNursery)) {
                 // No owner but field polygon.
                 sprintf(error_num, "%d", PolyNum);
                 g_msg->Warn(WARN_FILE, "Landscape::ReadPolys(): Farm polygon does not belong to a farm:", error_num);
                 exit(1);
             }
             if (-1 != Owner && Type != tole_Field && Type != tole_YoungForest && Type != tole_Orchard && Type != tole_PermPastureTussocky && Type != tole_PermPasture && Type != tole_PermanentSetaside && Type != tole_PermPastureLowYield && Type != tole_WoodyEnergyCrop && Type != tole_Vildtager && Type != tole_PlantNursery) {
                 // An owner but not field elements.
                 sprintf(error_num, "%d", PolyNum);
                 g_msg->Warn(WARN_FILE, "Landscape::ReadPolys(): Farm polygon does not have element type tole_Field:", error_num);
                 exit(1);
             }
 
             if (-1 != Owner)
             {
                 m_FarmManager->ConnectFarm(Owner);
                 m_FarmManager->AddField(Owner, newland, Owner);
                 if (g_map_le_borders.value())
                 {
                     if (random(100) < g_map_le_border_chance.value())
                     {
                         // This is a farm element, so signal adding a border.
                         newland->SetBorder((LE *)1);
                     }
                 }
                 // Code to generate unsprayed margins....
                 if (newland->GetElementType() == tole_Field)
                 {
                     if (g_map_le_unsprayedmargins.value())
                     {
                         if (random(100) < g_map_le_unsprayedmargins_chance.value())
                         {
                             // This is a farm field, so signal adding a margin
                             newland->SetUnsprayedMarginPolyRef(1);
                         }
                     }
                 }
                 // ..to here
             }
         }
     else {
             sprintf(error_num, "%d", PolyNum);
             g_msg->Warn(WARN_FILE, "Landscape::ReadPolys(): Duplicate polygon in file", error_num);
             exit(1);
         }
     }
     ifile.close();
     hb_first_free_poly_num = m_elems[NoPolygons - 1]->GetPoly() + 1;
 }

bool Landscape::ReadSymbols ( const char * a_cfgfile )

inline

Definition at line 737 of file landscape.h.

References g_cfg, and Configurator::ReadSymbols().

                                             {
     return g_cfg->ReadSymbols( a_cfgfile );
   }

void Landscape::RebuildPolyMapping ( )

inlineprotected

Definition at line 191 of file landscape.h.

References m_polymapping.

   {  // Rebuild m_polymapping.
       unsigned int sz = (int)m_elems.size();
       for (unsigned int i = 0; i < sz; i++) 
       {
           m_polymapping[m_elems[i]->GetPoly()] = i;
       }
   }

void Landscape::RecordGooseNumbers	(	int	a_poly,
		int	a_number
	)

This records the number of geese on the polygon the day before. To prevent lots of unnecessary clearing of values two values are saved, the number and simulation day - on reading the simulation day number can be used to modify the return value - see GetGooseNumbers()

This records the number of geese on the polygon the day before. To prevent lots of unnecessary clearing of values two values are saved, the number and simulation day - on reading the simulation day number can be used to modify the return value - see GetGooseNumbers()
Note that the record is the for the day before because this method is called by DoFirst, so there are no geese today

Definition at line 3106 of file Landscape.cpp.

 {
     int day = SupplyDayInYear();
     m_elems[m_polymapping[a_polyref]]->SetGooseNos(a_number, day);
 }

void Landscape::RecordGooseNumbersTimed	(	int	a_poly,
		int	a_number
	)

This records the number of geese on the polygon the day before at a predefined time. To prevent lots of unnecessary clearing of values two values are saved, the number and simulation day - on reading the simulation day number can be used to modify the return value - see GetGooseNumbers()

Definition at line 3119 of file Landscape.cpp.

 {
     int day = SupplyDayInYear();
     m_elems[m_polymapping[a_polyref]]->SetGooseNosTimed(a_number, day);
 }

void Landscape::RecordGooseSpNumbers	(	int	a_poly,
		int	a_number,
		GooseSpecies	a_goose
	)

This records the number of geese of each species on the polygon the day before. To prevent lots of unnecessary clearing of values two values are saved, the number and simulation day - on reading the simulation day number can be used to modify the return value - see GetGooseNumbers()

This records the number of geese on the polygon the day before by species. To prevent lots of unnecessary clearing of values two values are saved, the number and simulation day - on reading the simulation day number can be used to modify the return value - see GetGooseNumbers()
Note that the record is the for the day before because this method is called by DoFirst, so there are no geese today

Definition at line 3130 of file Landscape.cpp.

                                                                                       {
       int day = SupplyDayInYear();
       m_elems[m_polymapping[a_polyref]]->SetGooseSpNos(a_number, day, a_goose);
   }

void Landscape::RecordGooseSpNumbersTimed	(	int	a_poly,
		int	a_number,
		GooseSpecies	a_goose
	)

This records the number of geese of each species on the polygon the day before at a predefined time. To prevent lots of unnecessary clearing of values two values are saved, the number and simulation day - on reading the simulation day number can be used to modify the return value - see GetGooseNumbers()

This records the number of geese on the polygon the day before at a predefined time by species. To prevent lots of unnecessary clearing of values two values are saved, the number and simulation day - on reading the simulation day number can be used to modify the return value - see GetGooseNumbers()

Definition at line 3141 of file Landscape.cpp.

                                                                                              {
       int day = SupplyDayInYear();
       m_elems[m_polymapping[a_polyref]]->SetGooseSpNosTimed(a_number, day, a_goose);
   }

void Landscape::RemoveMissingValues ( void )

protected

A method for replacing missing values in the map with corrected ones - slow.

Definition at line 1904 of file Landscape.cpp.

References tole_Missing.

 {
     bool found; // the flag for something left to work with
     int mapwidth = m_land->MapWidth();
     int mapheight = m_land->MapHeight();
     int counter = 0;
     do
     {
         found = false; counter++;
         for (int x = 1; x < mapwidth-1; x++)
         {
             for (int y = 1; y < mapheight-1; y++)
             {
                 int apoly = m_land->Get(x,y);
                 if (m_elems[m_polymapping[apoly]]->GetElementType() == tole_Missing)
                 {
                     m_land->MissingCellReplace(x, y, true);
                 }
             }
         }
         counter++;
     } while (counter<50);
     // Now we only have the edges to deal with 
     for (int x = 0; x < mapwidth; x++)
     {
         for (int y = 0; y < mapheight; y++)
         {
             int apoly = m_land->Get(x, y);
             if (m_elems[m_polymapping[apoly]]->GetElementType() == tole_Missing)
             {
                 found = true;
                 counter++;
                 m_land->MissingCellReplaceWrap(x, y, true);
             }
         }
     }
     // Now we the ones that are not next to fields to deal with 
 }

int Landscape::RemoveSmallPolygons ( void )

protected

Removes small polygons from the map.

The method removes small polygons from the map and joins them with polygons that are close too them - there different rules depending on the type of polygon we have. Some small polygons can be legal, others need something done. Field polygons with management also have some minimum restrictions which are different from normal polygons.
This method is not written for efficiency, so simple brute force approaches are taken - it will take time to execute.

Rules:

Linear features: Isolated cells of these are possible, but they should not be separate polygons. These need to be joined together to form bigger, if not contiguous polygons
other 1m cell polygons need to be removed and replaced with the most common surrounding cell
Field polygons: If they are less than 1000m2 then they are assumed to be grassland

Definition at line 1998 of file Landscape.cpp.

References tole_FieldBoundary, tole_HedgeBank, tole_Hedges, tole_IndividualTree, tole_MetalledPath, tole_River, tole_RiversidePlants, tole_RiversideTrees, tole_RoadsideSlope, tole_RoadsideVerge, tole_SmallRoad, tole_StoneWall, tole_Stream, tole_Track, and tole_UnsprayedFieldMargin.

 {
     // To be sure we first count the map squares
     CountMapSquares();
     // First find polygons that don't match other rules and are single cells - remove these
     int removed = 0;
     for (unsigned int i = 0; i < m_elems.size(); i++)
     {
         if (m_elems[i]->GetArea() == 1)
         {
             TTypesOfLandscapeElement tole = m_elems[i]->GetElementType();
             switch (tole)
             {
                 case tole_FieldBoundary:
                 case tole_HedgeBank:
                 case tole_Hedges:
                 case tole_IndividualTree:
                 case tole_MetalledPath:
                 case tole_River:
                 case tole_RiversidePlants:
                 case tole_RiversideTrees:
                 case tole_RoadsideSlope:
                 case tole_RoadsideVerge:
                 case tole_SmallRoad:
                 case tole_StoneWall:
                 case tole_Stream:
                 case tole_Track:
                 case tole_UnsprayedFieldMargin:
                     // These could be part of a bigger polygon, so leave them alone for now.
                     break;
                 default:
                     // Get rid of this one.
                     APoint pt = m_elems[i]->GetCentroid();
                     m_land->CellReplacementNeighbour(pt.m_x, pt.m_y, m_elems[i]->GetPoly());
                     removed++;
             }
         }
     }
     return removed;
 }

void Landscape::RodenticidePredatorsEvaluation ( RodenticidePredators_Population_Manager * a_rppm )

Definition at line 2813 of file Landscape.cpp.

 {
     for (unsigned i=0; i<m_elems.size(); i++) {
         a_rppm->PreCachePoly(m_elems[i]->GetPoly());
     }
 }

void Landscape::SetBirdMaizeForage	(	int	a_polyref,
		double	a_fooddensity
	)

inline

Sets the maize forage resource as seen from a goose standpoint at a polygon.

Definition at line 499 of file landscape.h.

References m_polymapping.

                                                                  {
       m_elems[ m_polymapping[ a_polyref ] ]->SetBirdMaize( a_fooddensity );
   }

void Landscape::SetBirdSeedForage	(	int	a_polyref,
		double	a_fooddensity
	)

inline

Sets the grain forage resource as seen from a goose standpoint at a polygon.

Definition at line 492 of file landscape.h.

References m_polymapping.

   {
       m_elems[m_polymapping[a_polyref]]->SetBirdSeed(a_fooddensity);
   }

void Landscape::SetLESignal	(	int	a_polyref,
		LE_Signal	a_signal
	)

Definition at line 3334 of file Landscape.cpp.

                                                              {
     m_elems[m_polymapping[a_polyref]]->SetSignal(a_signal);
 }

void Landscape::SetMaleNewtPresent ( int a_InPondIndex )

inline

Sets a male as being present in a pond.

Definition at line 328 of file landscape.h.

328 { m_elems[a_InPondIndex]->SetMaleNewtPresent(true); }

Landscape::m_elems

vector< LE * > m_elems

List of all landscape elements. The index is a sequential number, to get the polynum look this number...

Definition: landscape.h:119

void Landscape::SetPolyMaxMinExtents ( void )

Definition at line 1434 of file Landscape.cpp.

 {
   // All polygon manipulation is settled now we need to give the polygons some information about themselves
   // This takes a little time but save time later one
     cout << "Setting max min polygon extents" << endl;
     int mwidth = m_land->MapWidth();
     int mheight = m_land->MapHeight();
     for ( int x = 0; x < mwidth; x++ ) {
         for ( int y = 0; y < mheight; y++ ) {
             int polyindex = m_land->Get( x, y );
             // Mark that we have seen this polygon.
             unsigned int ele_ref= polyindex;
             if (m_elems[m_polymapping[ele_ref]]->GetMaxX() < x) m_elems[m_polymapping[ele_ref]]->SetMaxX(x);
             if (m_elems[m_polymapping[ele_ref]]->GetMaxY() < y) m_elems[m_polymapping[ele_ref]]->SetMaxY(y);
             if (m_elems[m_polymapping[ele_ref]]->GetMinX() > x) m_elems[m_polymapping[ele_ref]]->SetMinX(x);
             if (m_elems[m_polymapping[ele_ref]]->GetMinY() > y) m_elems[m_polymapping[ele_ref]]->SetMinY(y);
             m_elems[m_polymapping[ele_ref]]->SetMapValid(true);
         }
     }
 }

void Landscape::SetThePopManager ( Population_Manager * a_ptr )

inline

Set the pointer to the current main population manager.

Definition at line 161 of file landscape.h.

161 { m_ThePopManager = a_ptr; }

Landscape::m_ThePopManager

Population_Manager * m_ThePopManager

a pointer to the current main population manager

Definition: landscape.h:143

void Landscape::SimulationClosingActions ( )

These are the things that are needed to be done after the simulation ends, but before landscape objects are deleted.

Definition at line 1282 of file Landscape.cpp.

References CfgBool::value().

 {
     if(cfg_OptimisingFarms.value()){
         this->m_FarmManager->PrintFinalResults();
     }
 }

void Landscape::SkylarkEvaluation ( SkTerritories * a_skt )

Definition at line 2806 of file Landscape.cpp.

                                                       {
     for (unsigned i=0; i<m_elems.size(); i++) {
         a_skt->PreCachePoly(m_elems[i]->GetPoly());
     }
 }

bool Landscape::StepOneValid	(	int	a_polyindex,
		int	a_x,
		int	a_y,
		int	step
	)

protected

Definition at line 2210 of file Landscape.cpp.

 {
   int index;
   int x_add[ 8 ] = { 1*a_step, 1*a_step, 0, -1*a_step, -1*a_step, -1*a_step, 0, 1*a_step };
   int y_add[ 8 ] = { 0, -1*a_step, -1*a_step, -1*a_step, 0, 1*a_step, 1*a_step, 1*a_step };
   int width = m_land->MapWidth();
   int height = m_land->MapHeight();
   // Scan anti-clockwise from center pixel coordinate.
   for ( unsigned int i = 0; i < 8; i++ ) {
     if ( ( a_x + x_add[ i ] < width ) && ( a_x + x_add[ i ] >= 0 ) && ( a_y + y_add[ i ] < height ) && ( a_y + y_add[ i ] >= 0 ) )
     {
         index = m_land->Get( a_x + x_add[ i ], a_y + y_add[ i ] );
         if (  index == a_polyindex )
         {
             m_elems[a_polyindex]->SetValidXY(a_x + x_add[ i ], a_y + y_add[ i ]);
             return true;
         }
     }
   }
   return false;
 }

bool Landscape::SubtractPondLarvalFood	(	double	a_food,
		int	a_polyrefindex
	)

Removes larval food from a pond and returns true if it was possible, otherwise false.

Definition at line 559 of file Landscape.cpp.

                                                                        {
     return dynamic_cast<Pond*>(m_elems[a_polyrefindex])->SubtractLarvalFood(a_food);
 }

double Landscape::SupplyBirdMaizeForage ( int a_polyref )

inline

Returns the maize forage resource.

Definition at line 591 of file landscape.h.

References m_polymapping.

                                                 {
       return m_elems[ m_polymapping[ a_polyref ] ]->GetBirdMaize();
   }

double Landscape::SupplyBirdMaizeForage	(	int	a_x,
		int	a_y
	)

inline

Returns the maize forage resource as seen from a goose standpoint at an x,y location.

Definition at line 597 of file landscape.h.

References RasterMap::Get().

                                                    {
       return m_elems[ m_land->Get( a_x, a_y ) ]->GetBirdMaize();
   }

double Landscape::SupplyBirdSeedForage ( int a_polyref )

inline

Returns the grain forage resource.

Definition at line 577 of file landscape.h.

References m_polymapping.

   {
       return m_elems[m_polymapping[a_polyref]]->GetBirdSeed();
   }

double Landscape::SupplyBirdSeedForage	(	int	a_x,
		int	a_y
	)

inline

Returns the grain forage resource as seen from a goose standpoint at an x,y location.

Definition at line 584 of file landscape.h.

References RasterMap::Get().

   {
       return m_elems[m_land->Get(a_x, a_y)]->GetBirdSeed();
   }

APoint Landscape::SupplyCentroid ( int a_polyref )

Definition at line 629 of file Landscape.cpp.

                                                 {
     return m_elems[ m_polymapping[ a_polyref ] ]->GetCentroid();
 }

APoint Landscape::SupplyCentroidIndex ( int a_polyrefindex )

Definition at line 634 of file Landscape.cpp.

                                                           {
     return m_elems[ a_polyrefindex ]->GetCentroid();
 }

int Landscape::SupplyCentroidX ( int a_polyref )

inline

Definition at line 436 of file landscape.h.

References m_polymapping.

                                        {
       return m_elems[ m_polymapping[ a_polyref ] ]->GetCentroidX();
   }

int Landscape::SupplyCentroidX	(	int	a_x,
		int	a_y
	)

inline

Definition at line 440 of file landscape.h.

References RasterMap::Get().

440 { return m_elems[ m_land->Get( a_x, a_y )]->GetCentroidX(); }

Landscape::m_elems

vector< LE * > m_elems

List of all landscape elements. The index is a sequential number, to get the polynum look this number...

Definition: landscape.h:119

RasterMap::Get

int Get(int a_x, int a_y)

Definition: rastermap.h:86

Landscape::m_land

RasterMap * m_land

The big map.

Definition: landscape.h:122

int Landscape::SupplyCentroidY ( int a_polyref )

inline

Definition at line 439 of file landscape.h.

References m_polymapping.

439 { return m_elems[m_polymapping[ a_polyref ]]->GetCentroidY(); }

Landscape::m_elems

vector< LE * > m_elems

List of all landscape elements. The index is a sequential number, to get the polynum look this number...

Definition: landscape.h:119

m_polymapping

int * m_polymapping

m_polymapping is a mapping from polygon numbers into the list of landscape elements, m_elems. When using this it is important that it is the poly num and not the map index that is used in calling.

Definition: Landscape.cpp:237

int Landscape::SupplyCentroidY	(	int	a_x,
		int	a_y
	)

inline

Definition at line 441 of file landscape.h.

References RasterMap::Get(), and GooseFieldListItem::polyref.

441 { return m_elems[ m_land->Get( a_x, a_y )]->GetCentroidY(); }

Landscape::m_elems

vector< LE * > m_elems

List of all landscape elements. The index is a sequential number, to get the polynum look this number...

Definition: landscape.h:119

RasterMap::Get

int Get(int a_x, int a_y)

Definition: rastermap.h:86

Landscape::m_land

RasterMap * m_land

The big map.

Definition: landscape.h:122

int Landscape::SupplyCountryDesig	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1053 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetCountryDesignation();
 }

double Landscape::SupplyDayDegrees ( int a_polyref )

inline

Definition at line 1250 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetDayDegrees();
 }

int Landscape::SupplyDayInMonth ( void )

inline

Definition at line 1532 of file landscape.h.

References g_date, and Calendar::GetDayInMonth().

 {
   return g_date->GetDayInMonth();
 }

int Landscape::SupplyDayInYear ( void )

inline

Definition at line 1522 of file landscape.h.

References Calendar::DayInYear(), and g_date.

Referenced by Rabbit_Population_Manager::DoFirst(), Rabbit_Population_Manager::DoLast(), FarmManager::FarmManagement(), and Rabbit_Warren::UpdateForageInformation().

 {
   return g_date->DayInYear();
 }

int Landscape::SupplyDaylength ( void )

inline

Definition at line 1456 of file landscape.h.

References Calendar::DayLength(), and g_date.

 {
   return g_date->DayLength();
 }

int Landscape::SupplyDaylength ( long a_date )

inline

Definition at line 1449 of file landscape.h.

References Calendar::DayLength(), and g_date.

 {
   return g_date->DayLength( a_date );
 }

double Landscape::SupplyDaylightProp ( )

inline

Definition at line 774 of file landscape.h.

References g_date, and Calendar::GetDaylightProportion().

774 { return g_date->GetDaylightProportion(); }

g_date

class Calendar * g_date

Definition: calendar.cpp:38

Calendar::GetDaylightProportion

double GetDaylightProportion(void)

Definition: calendar.h:73

double Landscape::SupplyDeadBiomass ( int a_polyref )

inline

Definition at line 950 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetDeadBiomass();
 }

double Landscape::SupplyDeadBiomass	(	int	a_x,
		int	a_y
	)

inline

Definition at line 955 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetDeadBiomass();
 }

int Landscape::SupplyElementSubType ( int a_polyref )

inline

Definition at line 1042 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetSubType();
 }

int Landscape::SupplyElementSubType	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1047 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetSubType();
 }

TTypesOfLandscapeElement Landscape::SupplyElementType ( int a_polyref )

inline

Definition at line 1031 of file landscape.h.

References m_polymapping.

Referenced by Rabbit_Population_Manager::WarrenLegalPos().

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetElementType();
 }

TTypesOfLandscapeElement Landscape::SupplyElementType	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1036 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetElementType();
 }

TTypesOfLandscapeElement Landscape::SupplyElementTypeCC	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1060 of file landscape.h.

 {
   a_x = (a_x + m_width10) % m_width;
   a_y = (a_y + m_height10) % m_height;
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetElementType();
 }

TTypesOfLandscapeElement Landscape::SupplyElementTypeFromVector ( unsigned int a_index )

inline

Definition at line 1025 of file landscape.h.

 {
   return m_elems[ a_index ]->GetElementType();
 }

int Landscape::SupplyFarmAnimalCensus	(	int	a_farm_ref,
		int	a_LifeStage
	)

Definition at line 608 of file Landscape.cpp.

Referenced by FarmManager::FarmManagement().

 { 
     return m_ThePopManager->FarmAnimalCensus(a_farm_ref, a_LifeStage); 
 }

int Landscape::SupplyFarmArea ( int a_polyref )

inline

Definition at line 1127 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetOwner()->GetArea();
 }

int Landscape::SupplyFarmIntensity	(	int	a_x,
		int	a_y
	)

Definition at line 619 of file Landscape.cpp.

Referenced by VegElement::DoDevelopment(), and VegElement::RecalculateBugsNStuff().

                                                      {
     return m_elems[ m_land->Get( a_x, a_y ) ]->GetOwner()->GetIntensity();
 }

int Landscape::SupplyFarmIntensity ( int a_polyref )

Definition at line 624 of file Landscape.cpp.

                                                   {
   return m_elems[ m_polymapping[ a_polyref  ]]->GetOwner()->GetIntensity();
 }

int Landscape::SupplyFarmIntensityI ( int a_polyindex )

Definition at line 614 of file Landscape.cpp.

                                                      {
     return m_elems[ a_polyindex ]->GetOwner()->GetIntensity();
 }

FarmManager* Landscape::SupplyFarmManagerPtr ( )

inline

Definition at line 332 of file landscape.h.

332 { return m_FarmManager; }

Landscape::m_FarmManager

FarmManager * m_FarmManager

List of all the farms.

Definition: landscape.h:116

int Landscape::SupplyFarmOwner	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1073 of file landscape.h.

                                                         {
     return m_elems[ m_land->Get( a_x, a_y ) ]->GetOwnerFile();
 }

int Landscape::SupplyFarmOwner ( int a_polyref )

inline

Definition at line 1079 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetOwnerFile();
 }

int Landscape::SupplyFarmOwnerIndex	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1086 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetOwnerIndex();
 }

int Landscape::SupplyFarmOwnerIndex ( int a_polyref )

inline

Definition at line 1093 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetOwnerIndex();
 }

Farm* Landscape::SupplyFarmPtr ( int a_owner )

inline

Definition at line 331 of file landscape.h.

References FarmManager::GetFarmPtr().

331 { return m_FarmManager->GetFarmPtr(a_owner); }

Landscape::m_FarmManager

FarmManager * m_FarmManager

List of all the farms.

Definition: landscape.h:116

FarmManager::GetFarmPtr

Farm * GetFarmPtr(int a_owner)

Returns the pointer to a farm with a specific number.

Definition: farm.h:1623

TTypesOfFarm Landscape::SupplyFarmType ( int a_polyref )

inline

Definition at line 1100 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetOwner()->GetType();
 }

TTypesOfFarm Landscape::SupplyFarmType	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1107 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetOwner()->GetType();
 }

long Landscape::SupplyGlobalDate ( void )

inline

Definition at line 1547 of file landscape.h.

References Calendar::Date(), and g_date.

Referenced by Rabbit_Female::st_EvaluateTerritory(), Rabbit_Female::st_GiveBirth(), and Rabbit_Warren::UpdateForageInformation().

 {
     return g_date->Date();
 }

double Landscape::SupplyGlobalRadiation ( )

inline

Definition at line 1267 of file landscape.h.

References g_weather, and Weather::GetGlobalRadiation().

Referenced by VegElement::RecalculateBugsNStuff().

 {
   return g_weather->GetGlobalRadiation( );
 }

double Landscape::SupplyGlobalRadiation ( long a_date )

inline

Definition at line 1272 of file landscape.h.

References g_weather, and Weather::GetGlobalRadiation().

 {
   return g_weather->GetGlobalRadiation( a_date );
 }

double Landscape::SupplyGooseGrazingForageH	(	double	a_height,
		GooseSpecies	a_goose
	)

inline

Returns the leaf forage resource as seen from a goose standpoint at a polygon based on the height only.

Parameters

a_height	[in] The vegetation height (assumed grass or cereals). This needs to be checked before calling
a_goose	[in] Is the type of goose calling which is needed to determine how to assess the value of the current forage availability (ie its different for different types of geese)

Returns: KJ/min

Definition at line 505 of file landscape.h.

Referenced by VegElement::RecalculateBugsNStuff().

   {
       if (a_goose == gs_Pinkfoot)
       {
           return m_GooseIntakeRateVSVegetationHeight_PF->GetY( a_height );
       }
       if (a_goose == gs_Barnacle)
       {
           return m_GooseIntakeRateVSVegetationHeight_BG->GetY(a_height);
       }
       if (a_goose == gs_Greylag)
       {
           return m_GooseIntakeRateVSVegetationHeight_GL->GetY(a_height);
       }
       Warn("Landscape::SupplyGooseGrazingForage", "Unknown Goose Type");
       exit(1);
   }

double Landscape::SupplyGooseGrazingForageH	(	int	a_polygon,
		GooseSpecies	a_goose
	)

inline

Returns the leaf forage resource as seen from a goose standpoint at a polygon referenced by number based on height only.

Parameters

a_polygon	[in] The polygon refence number for the polygon we are interested in (assumed grass or cereals). This needs to be checked before calling
a_goose	[in] Is the type of goose calling which is needed to determine how to assess the value of the current forage availability (ie its different for different types of geese)

Returns: KJ/min

Definition at line 530 of file landscape.h.

References m_polymapping.

   {
   if (a_goose == gs_Pinkfoot)
       {
           return m_GooseIntakeRateVSVegetationHeight_PF->GetY(m_elems[m_polymapping[a_polygon]]->GetVegHeight());
       }
       if (a_goose == gs_Barnacle)
       {
           return m_GooseIntakeRateVSVegetationHeight_BG->GetY(m_elems[m_polymapping[a_polygon]]->GetVegHeight());
       }
       if (a_goose == gs_Greylag)
       {
           return m_GooseIntakeRateVSVegetationHeight_GL->GetY(m_elems[m_polymapping[a_polygon]]->GetVegHeight());
       }      
       Warn("Landscape::SupplyGooseGrazingForage", "Unknown Goose Type");
       exit(1);
   }

int Landscape::SupplyGrazingPressure ( int a_polyref )

inline

Definition at line 1148 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ] ]->GetCattleGrazing();
 }

int Landscape::SupplyGrazingPressure	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1160 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetCattleGrazing();
 }

int Landscape::SupplyGrazingPressureVector ( unsigned int a_index )

inline

Definition at line 1153 of file landscape.h.

 {
   return m_elems[ a_index ]->GetCattleGrazing();
 }

double Landscape::SupplyGreenBiomass ( int a_polyref )

inline

Definition at line 938 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetGreenBiomass();
 }

double Landscape::SupplyGreenBiomass	(	int	a_x,
		int	a_y
	)

inline

Definition at line 943 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetGreenBiomass();
 }

bool Landscape::SupplyHasTramlines	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1173 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->HasTramlines();
 }

bool Landscape::SupplyHasTramlines ( int a_polyref )

inline

Definition at line 1167 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ] ]->HasTramlines();
 }

int Landscape::SupplyHour ( void )

inline

Get the hour of the day.

Definition at line 1512 of file landscape.h.

References g_date, and Calendar::GetHour().

                                        {
     return g_date->GetHour();
 }

double Landscape::SupplyHumidity ( void )

inline

Definition at line 1319 of file landscape.h.

References g_weather, and Weather::GetHumidity().

 {
     return g_weather->GetHumidity();
 }

double Landscape::SupplyInsects ( int a_polyref )

inline

Definition at line 1009 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetInsectPop();
 }

double Landscape::SupplyInsects	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1014 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetInsectPop();
 }

bool Landscape::SupplyIsCereal ( int a_polyref )

inline

Definition at line 1220 of file landscape.h.

References m_polymapping.

 {
     return m_elems[m_polymapping[a_polyref]]->IsCereal();
 }

bool Landscape::SupplyIsGrass ( int a_polyref )

inline

Definition at line 1230 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ] ]->IsGrass();
 }

bool Landscape::SupplyIsMatureCereal ( int a_polyref )

inline

Definition at line 1225 of file landscape.h.

References m_polymapping.

 {
     return m_elems[m_polymapping[a_polyref]]->IsMatureCereal();
 }

bool Landscape::SupplyJustMown ( int a_polyref )

inline

Definition at line 1184 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ] ]->IsRecentlyMown();
 }

bool Landscape::SupplyJustMownVector ( unsigned int a_index )

inline

Definition at line 1179 of file landscape.h.

 {
   return m_elems[ a_index ]->IsRecentlyMown();
 }

int Landscape::SupplyJustSprayed ( int a_polyref )

inline

Definition at line 1196 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ] ]->IsRecentlySprayed();
 }

int Landscape::SupplyJustSprayed	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1201 of file landscape.h.

 {
   return m_elems[  m_land->Get( a_x, a_y ) ]->IsRecentlySprayed();
 }

int Landscape::SupplyJustSprayedVector ( unsigned int a_index )

inline

Definition at line 1191 of file landscape.h.

 {
   return m_elems[ a_index ]->IsRecentlySprayed();
 }

double Landscape::SupplyLAGreen ( int a_polyref )

inline

Definition at line 962 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetLAGreen();
 }

double Landscape::SupplyLAGreen	(	int	a_x,
		int	a_y
	)

inline

Definition at line 931 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetLAGreen();
 }

polylist * Landscape::SupplyLargeOpenFieldsNearXY	(	int	x,
		int	y,
		int	range,
		int	a_openness
	)

Returns a pointer to a list of polygonrefs to large open fields within a range of location x,y.

There is a limit of 1000 polygons to return. There are probably more speed efficient ways to do this, but the simplest is to simply trawl through the list of polygons and pull out each polygon with an openness score > a_openness - then see if the centroid is within range. NB calling method must delete the polylist* passed back!

18/12/2013 this method has been rendered obselete by changes to hunters referring to famers rather than a co-ordinate and range.

Calculates distance from location a_x, a_y. This is done using an approximation to pythagorus to avoid a speed problem.

NB this will crash if either a_dy or a_dx are zero!

Definition at line 645 of file Landscape.cpp.

 {
     polylist* p_list = new polylist;
     unsigned sz = (unsigned) m_elems.size();
     for (unsigned i=0; i<sz; i++)
     {
         if ( m_elems[i]->GetOpenness() > a_openness)
         {
             APoint pt = m_elems[i]->GetCentroid();
             int dx, dy;
             if (a_x>pt.m_x) dx = a_x-pt.m_x; else dx = pt.m_x-a_x;
             if (a_y>pt.m_y) dy = a_y-pt.m_y; else dy = pt.m_y-a_y;
             dx++; dy++; // prevents crash with maths below.
             int dist;
             if (dx>dy) dist = dx + (dy * dy) /(2 * dx); else dist = dy + (dx * dx) /(2 * dy);
             if (dist<=a_range) p_list->push_back( m_elems[i]->GetPoly());
         }
     }
     return p_list;
 }

int Landscape::SupplyLargestPolyNumUsed ( )

inline

Definition at line 334 of file landscape.h.

334 { return m_LargestPolyNumUsed; }

Landscape::m_LargestPolyNumUsed

int m_LargestPolyNumUsed

Definition: landscape.h:172

TTypesOfVegetation Landscape::SupplyLastSownVeg ( int a_polyref )

inline

Definition at line 989 of file landscape.h.

References m_polymapping.

 {
     return m_elems[m_polymapping[a_polyref]]->GetLastSownVeg();
 }

TTypesOfVegetation Landscape::SupplyLastSownVeg	(	int	a_x,
		int	a_y
	)

inline

Definition at line 994 of file landscape.h.

 {
     return m_elems[m_land->Get(a_x, a_y)]->GetLastSownVeg();
 }

TTypesOfVegetation Landscape::SupplyLastSownVegVector ( unsigned int a_index )

inline

Definition at line 984 of file landscape.h.

 {
     return m_elems[a_index]->GetLastSownVeg();
 }

int Landscape::SupplyLastTreatment	(	int	a_polyref,
		int *	a_index
	)

inline

Definition at line 1255 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetLastTreatment( a_index );
 }

int Landscape::SupplyLastTreatment	(	int	a_x,
		int	a_y,
		int *	a_index
	)

inline

Definition at line 1262 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetLastTreatment( a_index );
 }

double Landscape::SupplyLATotal	(	int	a_x,
		int	a_y
	)

inline

Definition at line 925 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetLATotal();
 }

int Landscape::SupplyLECount ( void )

Definition at line 3326 of file Landscape.cpp.

                                  {
     return (int)m_elems.size();
 }

bool Landscape::SupplyLEHigh	(	int	a_x,
		int	a_y
	)

inline

Tests whether the polygon at a_x,a_y is designated as high.

Definition at line 421 of file landscape.h.

References RasterMap::Get().

421 { return m_elems[ m_land->Get( a_x, a_y ) ]->GetHigh(); }

Landscape::m_elems

vector< LE * > m_elems

List of all landscape elements. The index is a sequential number, to get the polynum look this number...

Definition: landscape.h:119

RasterMap::Get

int Get(int a_x, int a_y)

Definition: rastermap.h:86

Landscape::m_land

RasterMap * m_land

The big map.

Definition: landscape.h:122

int Landscape::SupplyLENext ( void )

Definition at line 3319 of file Landscape.cpp.

                                 {
     if ((unsigned int)le_signal_index == m_elems.size()) {
         return -1;
     }
     return m_elems[le_signal_index++]->GetPoly();
 }

LE * Landscape::SupplyLEPointer ( int a_polyref )

inline

Definition at line 1020 of file landscape.h.

References m_polymapping.

Referenced by Farm::AutumnHarrow(), Farm::AutumnPlough(), Farm::AutumnRoll(), Farm::AutumnSow(), Farm::BurnStrawStubble(), Farm::CattleIsOut(), Farm::CattleIsOutLow(), Farm::CattleOut(), Farm::CattleOutLowGrazing(), Farm::CutOrch(), Farm::CutToHay(), Farm::CutToSilage(), Farm::CutWeeds(), Farm::DeepPlough(), Field::DoDevelopment(), Farm::FA_AmmoniumSulphate(), Farm::FA_GreenManure(), Farm::FA_Manure(), Farm::FA_NPK(), Farm::FA_PK(), Farm::FA_Sludge(), Farm::FA_Slurry(), Farm::FP_GreenManure(), Farm::FP_LiquidNH3(), Farm::FP_ManganeseSulphate(), Farm::FP_Manure(), Farm::FP_NPK(), Farm::FP_NPKS(), Farm::FP_PK(), Farm::FP_Sludge(), Farm::FP_Slurry(), Farm::Harvest(), OptimisingFarm::Harvest(), Farm::HarvestLong(), Farm::HayBailing(), Farm::HayTurning(), Farm::HillingUp(), Rabbit_Warren::InitEvaluation(), Farm::PigsAreOut(), Farm::PigsAreOutForced(), Farm::PigsOut(), Farm::RowCultivation(), Farm::SleepAllDay(), Farm::SpringHarrow(), Farm::SpringPlough(), Farm::SpringRoll(), Farm::SpringSow(), Farm::StrawChopping(), Farm::Strigling(), Farm::StriglingSow(), Farm::StubbleHarrowing(), Farm::Swathing(), UnsprayedMarginScan(), Farm::Water(), and Farm::WinterPlough().

 {
   return m_elems[ m_polymapping[ a_polyref ]];
 }

void Landscape::SupplyLEReset ( void )

Definition at line 3315 of file Landscape.cpp.

                                   {
     le_signal_index = 0;
 }

LE_Signal Landscape::SupplyLESignal ( int a_polyref )

Definition at line 3330 of file Landscape.cpp.

                                                  {
     return m_elems[m_polymapping[a_polyref]]->GetSignal();
 }

int * Landscape::SupplyMagicMapP	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1435 of file landscape.h.

 {
   return m_land->GetMagicP( a_x, a_y );
 }

bool Landscape::SupplyMaleNewtPresent ( int a_InPondIndex )

inline

Determines if a male is present in a pond.

Definition at line 330 of file landscape.h.

330 { return m_elems[a_InPondIndex]->IsMaleNewtPresent(); }

Landscape::m_elems

vector< LE * > m_elems

List of all landscape elements. The index is a sequential number, to get the polynum look this number...

Definition: landscape.h:119

double Landscape::SupplyMeanTemp	(	long	a_date,
		unsigned int	a_period
	)

inline

Definition at line 1298 of file landscape.h.

References g_weather, and Weather::GetMeanTemp().

 {
   return g_weather->GetMeanTemp( a_date, a_period );
 }

int Landscape::SupplyMinute ( void )

inline

Get the minute of the hour.

Definition at line 1518 of file landscape.h.

References g_date, and Calendar::GetMinute().

                                          {
     return g_date->GetMinute();
 }

int Landscape::SupplyMonth ( void )

inline

Definition at line 1527 of file landscape.h.

References g_date, and Calendar::GetMonth().

 {
   return g_date->GetMonth();
 }

double Landscape::SupplyNightProp ( )

inline

Definition at line 775 of file landscape.h.

References g_date, g_map, and Calendar::GetDaylightProportion().

775 { return 1.0-g_date->GetDaylightProportion(); }

g_date

class Calendar * g_date

Definition: calendar.cpp:38

Calendar::GetDaylightProportion

double GetDaylightProportion(void)

Definition: calendar.h:73

int Landscape::SupplyNumberOfFarms ( )

inline

Definition at line 1069 of file landscape.h.

                                            {
     return m_FarmManager->GetNoFarms();
 }

unsigned int Landscape::SupplyNumberOfPolygons ( void )

inline

Definition at line 1387 of file landscape.h.

 {
   return (unsigned int) m_elems.size();
 }

int Landscape::SupplyOpenness ( int a_poly )

inline

Get openness for a polygon.

Definition at line 417 of file landscape.h.

References m_polymapping.

417 { return m_elems[m_polymapping[ a_poly ]]->GetOpenness(); }

Landscape::m_elems

vector< LE * > m_elems

List of all landscape elements. The index is a sequential number, to get the polynum look this number...

Definition: landscape.h:119

m_polymapping

int * m_polymapping

m_polymapping is a mapping from polygon numbers into the list of landscape elements, m_elems. When using this it is important that it is the poly num and not the map index that is used in calling.

Definition: Landscape.cpp:237

int Landscape::SupplyOpenness	(	int	a_x,
		int	a_y
	)

inline

Get openness for a location.

Definition at line 419 of file landscape.h.

References RasterMap::Get().

419 { return m_elems[ m_land->Get( a_x, a_y )]->GetOpenness(); }

Landscape::m_elems

vector< LE * > m_elems

List of all landscape elements. The index is a sequential number, to get the polynum look this number...

Definition: landscape.h:119

RasterMap::Get

int Get(int a_x, int a_y)

Definition: rastermap.h:86

Landscape::m_land

RasterMap * m_land

The big map.

Definition: landscape.h:122

TTypesOfOptFarms Landscape::SupplyOptFarmType	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1112 of file landscape.h.

 {
     OptimisingFarm * opf;       
     opf =  dynamic_cast<OptimisingFarm*>(m_elems[ m_land->Get( a_x, a_y ) ]->GetOwner());
     return opf-> Get_farmType();
 }

bool Landscape::SupplyOverspray	(	int	a_x,
		int	a_y
	)

Gets the overspray flag.

Definition at line 494 of file Landscape.cpp.

 {
     return m_elems[m_land->Get(a_x, a_y)]->GetSprayedToday();
 }

double Landscape::SupplyPesticide	(	int	a_x,
		int	a_y
	)

Gets total pesticide for a location.

Definition at line 481 of file Landscape.cpp.

References g_pest, and Pesticide::SupplyPesticide().

Referenced by Pond::CalcPondPesticide(), and Rabbit_Warren::UpdatePesticide().

                                                   {
     double pp;
 #ifdef __DETAILED_PESTICIDE_FATE
     // This should be avoided if possible because it is inefficient
     pp = g_pest->SupplyPesticideS(a_x, a_y);
     pp += g_pest->SupplyPesticideP(a_x, a_y);
 #else
     pp = g_pest->SupplyPesticide(a_x, a_y);
 #endif
     return pp;
 }

double Landscape::SupplyPesticide ( int a_polyref )

Gets total pesticide for the centroid of a polygon.

Definition at line 522 of file Landscape.cpp.

References g_pest, Pesticide::SupplyPesticide(), and CfgBool::value().

                                                {
     if (!l_pest_enable_pesticide_engine.value()) return 0.0;
     double pp;
 #ifdef __DETAILED_PESTICIDE_FATE
     pp = g_pest->SupplyPesticideS(a_polyref);
     pp += g_pest->SupplyPesticideP(a_polyref);
 #else
     pp = g_pest->SupplyPesticide(a_polyref);
 #endif
     return pp;
 }

int Landscape::SupplyPesticideCell ( int a_polyref )

inline

Definition at line 1394 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ] ]->GetPesticideCell();
 }

bool Landscape::SupplyPesticideDecay ( )

Returns true if there is any pesticide in the system at all at this point.

Definition at line 639 of file Landscape.cpp.

References g_pest, and Pesticide::GetAnythingToDecay().

Referenced by Rabbit_Warren::UpdatePesticide().

 {
     return g_pest->GetAnythingToDecay(); 
 }

double Landscape::SupplyPesticideP	(	int	a_x,
		int	a_y
	)

Gets plant pesticide for a location.

Definition at line 500 of file Landscape.cpp.

References g_pest, and Pesticide::SupplyPesticide().

                                                    {
     double pp;
 #ifdef __DETAILED_PESTICIDE_FATE
     pp = g_pest->SupplyPesticideP(a_x, a_y);
 #else
     pp = g_pest->SupplyPesticide(a_x, a_y);
 #endif
     return pp;
 }

double Landscape::SupplyPesticideP ( int a_polyref )

Gets plant pesticide for the centroid of a polygon.

Definition at line 547 of file Landscape.cpp.

References g_pest, Pesticide::SupplyPesticide(), and CfgBool::value().

                                                 {
     if (!l_pest_enable_pesticide_engine.value()) return 0.0;
     double pp;
 #ifdef __DETAILED_PESTICIDE_FATE
     pp = g_pest->SupplyPesticideP(a_polyref);
 #else
     pp = g_pest->SupplyPesticide(a_polyref);
 #endif
     return pp;
 }

double Landscape::SupplyPesticideS	(	int	a_x,
		int	a_y
	)

Gets soil pesticide for a location.

Definition at line 511 of file Landscape.cpp.

References g_pest, and Pesticide::SupplyPesticide().

                                                    {
     double pp;
 #ifdef __DETAILED_PESTICIDE_FATE
     pp = g_pest->SupplyPesticideS(a_x, a_y);
 #else
     pp = g_pest->SupplyPesticide(a_x, a_y);
 #endif
     return pp;
 }

double Landscape::SupplyPesticideS ( int a_polyref )

Gets soil pesticide for the centroid of a polygon.

Definition at line 535 of file Landscape.cpp.

References g_pest, Pesticide::SupplyPesticide(), and CfgBool::value().

                                                 {
     if (!l_pest_enable_pesticide_engine.value()) return 0.0;
     double pp;
 #ifdef __DETAILED_PESTICIDE_FATE
     pp = g_pest->SupplyPesticideS(a_polyref);
 #else
     pp = g_pest->SupplyPesticide(a_polyref);
 #endif
     return pp;
 }

TTypesOfPesticide Landscape::SupplyPesticideType ( void )

inline

Definition at line 401 of file landscape.h.

Referenced by Rabbit_Juvenile::InternalPesticideHandlingAndResponse(), Rabbit_Male::InternalPesticideHandlingAndResponse(), and Rabbit_Female::InternalPesticideHandlingAndResponse().

401 { return m_PesticideType; }

Landscape::m_PesticideType

TTypesOfPesticide m_PesticideType

An attribute to hold the pesticide type being tested, if there is one, if not default is -1...

Definition: landscape.h:256

double Landscape::SupplyPolygonArea ( int a_polyref )

inline

Definition at line 487 of file landscape.h.

References m_polymapping.

487 { return m_elems[ m_polymapping[ a_polyref ]]->GetArea(); }

Landscape::m_elems

vector< LE * > m_elems

List of all landscape elements. The index is a sequential number, to get the polynum look this number...

Definition: landscape.h:119

m_polymapping

int * m_polymapping

m_polymapping is a mapping from polygon numbers into the list of landscape elements, m_elems. When using this it is important that it is the poly num and not the map index that is used in calling.

Definition: Landscape.cpp:237

double Landscape::SupplyPolygonAreaVector ( int a_polyref )

inline

Returns the area of a polygon using the vector index as a reference.

Definition at line 1121 of file landscape.h.

 {
   return m_elems[ a_polyref ]->GetArea();
 }

int Landscape::SupplyPolyRef	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1414 of file landscape.h.

Referenced by Pond::CalcPondPesticide(), Rabbit_Warren::InitEvaluation(), and Rabbit_Warren::UpdatePesticide().

 {
   return m_elems[ m_land->Get( a_x, a_y )]->GetPoly();
 }

int Landscape::SupplyPolyRefCC	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1426 of file landscape.h.

 {
   a_x = (a_x + m_width10) % m_width;
   a_y = (a_y + m_height10) % m_height;
   return m_elems[ m_land->Get( a_x, a_y )]->GetPoly();
 }

int Landscape::SupplyPolyRefIndex	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1419 of file landscape.h.

 {
   return m_land->Get( a_x, a_y );
 }

int Landscape::SupplyPolyRefVector ( unsigned int a_index )

inline

Definition at line 1377 of file landscape.h.

 {
   return m_elems[ a_index ]->GetPoly();
 }

int Landscape::SupplyPondIndex ( int a_pondref )

inline

Returns the index of a pond based on pondref or -1 if not found.

Definition at line 321 of file landscape.h.

                                      {
       for (int i = 0; i < m_PondIndexList.size(); i++) {
           if (m_PondRefsList[i] == a_pondref) return m_PondIndexList[i];
       }
       return -1;
   }

double Landscape::SupplyPondPesticide ( int a_poly_index )

inline

Get the pesticide concentration per liter from a pond (must be a pond index on calling)

Definition at line 710 of file landscape.h.

References SupplyPondPesticide().

Referenced by SupplyPondPesticide().

710 { return dynamic_cast<Pond*>(m_elems[a_poly_index])->SupplyPondPesticide(); }

Landscape::m_elems

vector< LE * > m_elems

List of all landscape elements. The index is a sequential number, to get the polynum look this number...

Definition: landscape.h:119

Landscape::SupplyPondPesticide

double SupplyPondPesticide(int a_poly_index)

Get the pesticide concentration per liter from a pond (must be a pond index on calling) ...

Definition: landscape.h:710

Pond

Ponds are defined as freshwater bodies between 25m2 and 5000m2. For newts the effective size is limit...

Definition: elements.h:1082

double Landscape::SupplyRain ( void )

inline

Definition at line 1291 of file landscape.h.

References g_weather, and Weather::GetRain().

Referenced by Rabbit_Population_Manager::DoFirst(), and Pesticide::Tick().

 {
   return g_weather->GetRain();
 }

double Landscape::SupplyRain ( long a_date )

inline

Definition at line 1284 of file landscape.h.

References g_weather, and Weather::GetRain().

 {
   return g_weather->GetRain( a_date );
 }

double Landscape::SupplyRainPeriod	(	long	a_date,
		int	a_period
	)

inline

Definition at line 1277 of file landscape.h.

References g_weather, and Weather::GetRainPeriod().

 {
   return g_weather->GetRainPeriod( a_date, a_period );
 }

int Landscape::SupplyRandomPondIndex ( )

Returns random pond index.

Definition at line 2387 of file Landscape.cpp.

References g_rand_uni().

                                      { 
     return m_PondIndexList[int(g_rand_uni()*m_PondIndexList.size())]; 
 }

int Landscape::SupplyRandomPondRef ( )

Returns random pond polyref.

Definition at line 2391 of file Landscape.cpp.

References g_rand_uni().

                                    { 
     if (m_PondIndexList.size()>0) return m_PondRefsList[int(g_rand_uni()*m_PondIndexList.size())]; 
     return -1;
 }

int Landscape::SupplyRoadWidth	(	int	,
		int
	)

inline

Definition at line 760 of file landscape.h.

760 {return 0;}

double Landscape::SupplyRodenticide	(	int	a_x,
		int	a_y
	)

Gets total rodenticide for a location.

Definition at line 470 of file Landscape.cpp.

References cfg_rodenticide_enable, and CfgBool::value().

                                                     {
     if (cfg_rodenticide_enable.value())
     {
         double pp;
         pp = m_RodenticideManager->GetRodenticide(a_x, a_y);
         return pp;
     }
     return 0;
 }

RodenticidePredators_Population_Manager* Landscape::SupplyRodenticidePredatoryManager ( )

inline

Definition at line 400 of file landscape.h.

400 { return m_RodenticidePreds; }

Landscape::m_RodenticidePreds

RodenticidePredators_Population_Manager * m_RodenticidePreds

Definition: landscape.h:146

bool Landscape::SupplyShouldSpray ( )

inline

Definition at line 336 of file landscape.h.

Referenced by Orchard::DoDevelopment(), and OrchardBand::DoDevelopment().

336 {return m_toxShouldSpray;}

Landscape::m_toxShouldSpray

bool m_toxShouldSpray

Definition: landscape.h:295

int Landscape::SupplySimAreaHeight ( void )

inline

Definition at line 1563 of file landscape.h.

Referenced by TAnimal::CorrectWrapRound(), Rabbit_Warren::InitEvaluation(), and Population_Manager::Population_Manager().

 {
   return m_height;
 }

int Landscape::SupplySimAreaMaxExtent ( void )

inline

Definition at line 1568 of file landscape.h.

 {
   return m_maxextent;
 }

int Landscape::SupplySimAreaMinExtent ( void )

int Landscape::SupplySimAreaWidth ( void )

inline

Definition at line 1558 of file landscape.h.

Referenced by TAnimal::CorrectWrapRound(), Rabbit_Warren::InitEvaluation(), and Rabbit_Population_Manager::Rabbit_Population_Manager().

 {
   return m_width;
 }

bool Landscape::SupplySkScrapes ( int a_polyref )

inline

Definition at line 902 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetSkScrapes();
 }

bool Landscape::SupplySnowcover ( void )

inline

Definition at line 1363 of file landscape.h.

References g_weather, and Weather::GetSnow().

 {
   return g_weather->GetSnow();
 }

bool Landscape::SupplySnowcover ( long a_date )

inline

Definition at line 1356 of file landscape.h.

References g_weather, and Weather::GetSnow().

 {
   return g_weather->GetSnow( a_date );
 }

double Landscape::SupplySnowDepth ( void )

inline

Definition at line 1370 of file landscape.h.

References g_weather, and Weather::GetSnowDepth().

 {
   return g_weather->GetSnowDepth();
 }

int Landscape::SupplySoilType	(	int	a_x,
		int	a_y
	)

inline

Returns the soil type in ALMaSS types reference numbers.

Definition at line 426 of file landscape.h.

References RasterMap::Get().

                                          {
       return m_elems[ m_land->Get( a_x, a_y ) ]->GetSoilType( );
   }

int Landscape::SupplySoilTypeR	(	int	a_x,
		int	a_y
	)

inline

Returns the soil type in rabbit warren reference numbers.

Definition at line 430 of file landscape.h.

References RasterMap::Get().

Referenced by Rabbit_Population_Manager::PreProcessWarrenLocations().

                                           {
       return m_elems[ m_land->Get( a_x, a_y ) ]->GetSoilTypeR( );
   }

double Landscape::SupplyTemp ( void )

inline

Definition at line 1312 of file landscape.h.

References g_weather, and Weather::GetTemp().

Referenced by Rabbit_Population_Manager::DoFirst(), and VegElement::RecalculateBugsNStuff().

 {
     return g_weather->GetTemp();
 }

double Landscape::SupplyTemp ( long a_date )

inline

Definition at line 1305 of file landscape.h.

References g_weather, and Weather::GetTemp().

 {
   return g_weather->GetTemp( a_date );
 }

double Landscape::SupplyTempPeriod	(	long	a_date,
		int	a_period
	)

inline

Definition at line 1336 of file landscape.h.

References g_weather, and Weather::GetTempPeriod().

 {
   return g_weather->GetTempPeriod( a_date, a_period );
 }

Population_Manager* Landscape::SupplyThePopManager ( )

inline

Get the pointer to the current main population manager.

Definition at line 159 of file landscape.h.

159 { return m_ThePopManager; }

Landscape::m_ThePopManager

Population_Manager * m_ThePopManager

a pointer to the current main population manager

Definition: landscape.h:143

double Landscape::SupplyTrafficLoad	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1214 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetTrafficLoad();
 }

double Landscape::SupplyTrafficLoad ( int a_polyref )

inline

Definition at line 1208 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ] ]->GetTrafficLoad();
 }

int Landscape::SupplyTreeAge ( int a_Polyref )

inline

Definition at line 1237 of file landscape.h.

 {
   return 1;
 }

int Landscape::SupplyTreeAge	(	int	,
		int
	)

inline

Definition at line 473 of file landscape.h.

473 {return 0;}

int Landscape::SupplyTreeHeight	(	int	,
		int
	)

inline

Definition at line 763 of file landscape.h.

763 {return 0;}

int Landscape::SupplyTreeHeight ( int )

inline

Definition at line 765 of file landscape.h.

765 {return 0;}

int Landscape::SupplyUnderGrowthWidth	(	int	,
		int
	)

inline

Definition at line 764 of file landscape.h.

764 {return 0;}

int Landscape::SupplyUnderGrowthWidth ( int )

inline

Definition at line 766 of file landscape.h.

766 {return 0;}

int Landscape::SupplyValidX ( int a_polyref )

inline

Definition at line 1400 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ] ]->GetValidX();
 }

int Landscape::SupplyValidY ( int a_polyref )

inline

Definition at line 1407 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ] ]->GetValidY();
 }

int Landscape::SupplyVegAge ( int a_Polyref )

inline

Definition at line 999 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetVegAge();
 }

int Landscape::SupplyVegAge	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1004 of file landscape.h.

 {
     return m_elems[m_land->Get(a_x, a_y)]->GetVegAge();
 }

double Landscape::SupplyVegBiomass ( int a_polyref )

inline

Definition at line 874 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetVegBiomass();
 }

double Landscape::SupplyVegBiomass	(	int	a_x,
		int	a_y
	)

inline

Definition at line 879 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetVegBiomass();
 }

double Landscape::SupplyVegBiomassVector ( unsigned int a_index )

inline

Definition at line 869 of file landscape.h.

 {
   return m_elems[ a_index ]->GetVegBiomass();
 }

double Landscape::SupplyVegCover ( int a_polyref )

inline

Definition at line 969 of file landscape.h.

References m_polymapping.

Referenced by Pesticide::MainMapDecay().

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetVegCover();
 }

double Landscape::SupplyVegCover	(	int	a_x,
		int	a_y
	)

inline

Definition at line 979 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetVegCover();
 }

double Landscape::SupplyVegCoverVector ( unsigned int a_index )

inline

Definition at line 974 of file landscape.h.

 {
   return m_elems[ a_index ]->GetVegCover();
 }

int Landscape::SupplyVegDensity ( int a_polyref )

inline

Definition at line 896 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetVegDensity();
 }

int Landscape::SupplyVegDensity	(	int	a_x,
		int	a_y
	)

inline

Definition at line 919 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetVegDensity();
 }

double Landscape::SupplyVegDigestability ( int a_polyref )

inline

Definition at line 840 of file landscape.h.

References m_polymapping.

Referenced by Rabbit_Warren::UpdateForageInformation().

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetDigestability();
 }

double Landscape::SupplyVegDigestability	(	int	a_x,
		int	a_y
	)

inline

Definition at line 846 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetDigestability();
 }

double Landscape::SupplyVegDigestabilityVector ( unsigned int a_index )

inline

Definition at line 835 of file landscape.h.

 {
   return m_elems[ a_index ]->GetDigestability();
 }

double Landscape::SupplyVegHeight ( int a_polyref )

inline

Definition at line 857 of file landscape.h.

References m_polymapping.

Referenced by Rabbit_Warren::UpdateForageInformation().

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetVegHeight();
 }

double Landscape::SupplyVegHeight	(	int	a_x,
		int	a_y
	)

inline

Definition at line 862 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetVegHeight();
 }

double Landscape::SupplyVegHeightVector ( unsigned int a_index )

inline

Definition at line 852 of file landscape.h.

 {
   return m_elems[ a_index ]->GetVegHeight();
 }

bool Landscape::SupplyVegPatchy ( int a_polyref )

inline

Definition at line 907 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetVegPatchy();
 }

bool Landscape::SupplyVegPatchy	(	int	a_x,
		int	a_y
	)

inline

Definition at line 913 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetVegPatchy();
 }

int Landscape::SupplyVegPhase ( int a_poly )

inline

Definition at line 164 of file landscape.h.

References m_polymapping.

                                  {
       return m_elems[m_polymapping[a_poly]]->GetVegPhase();
   }

TTypesOfVegetation Landscape::SupplyVegType	(	int	a_x,
		int	a_y
	)

inline

Definition at line 1243 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetVegType();
 }

TTypesOfVegetation Landscape::SupplyVegType ( int polyref )

inline

Definition at line 1135 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ] ]->GetVegType();
 }

TTypesOfVegetation Landscape::SupplyVegTypeVector ( unsigned int a_index )

inline

Definition at line 1141 of file landscape.h.

 {
   return m_elems[ a_index ]->GetVegType();
 }

const char* Landscape::SupplyVersion ( void )

inline

Definition at line 727 of file landscape.h.

727 { return m_versioninfo; }

Landscape::m_versioninfo

char m_versioninfo[30]

Definition: landscape.h:112

double Landscape::SupplyWeedBiomass ( int a_polyref )

inline

Definition at line 885 of file landscape.h.

References m_polymapping.

 {
   return m_elems[ m_polymapping[ a_polyref ]]->GetWeedBiomass();
 }

double Landscape::SupplyWeedBiomass	(	int	a_x,
		int	a_y
	)

inline

Definition at line 891 of file landscape.h.

 {
   return m_elems[ m_land->Get( a_x, a_y ) ]->GetWeedBiomass();
 }

double Landscape::SupplyWind ( void )

inline

Definition at line 1343 of file landscape.h.

References g_weather, and Weather::GetWind().

 {
   return g_weather->GetWind();
 }

double Landscape::SupplyWind ( long a_date )

inline

Definition at line 1326 of file landscape.h.

References g_weather, and Weather::GetWind().

 {
   return g_weather->GetWind( a_date );
 }

int Landscape::SupplyWindDirection ( void )

inline

Definition at line 1349 of file landscape.h.

References g_weather, and Weather::GetWindDirection().

Referenced by Pesticide::DailyQueueProcess().

 {
     return g_weather->GetWindDirection();
 }

double Landscape::SupplyWindPeriod	(	long	a_date,
		int	a_period
	)

inline

Definition at line 1331 of file landscape.h.

References g_weather, and Weather::GetWindPeriod().

 {
   return g_weather->GetWindPeriod( a_date, a_period );
 }

int Landscape::SupplyYear ( void )

inline

Definition at line 1537 of file landscape.h.

References g_date, and Calendar::GetYear().

 {
     return g_date->GetYear();
 }

int Landscape::SupplyYearNumber ( void )

inline

Definition at line 1542 of file landscape.h.

References g_date, and Calendar::GetYearNumber().

Referenced by Rabbit_Population_Manager::DoFirst(), FarmManager::FarmManagement(), and Farm::Trial_PesticideTreat_DateLimited().

 {
     return g_date->GetYearNumber();
 }

void Landscape::TestCropManagement ( void )

protected

void Landscape::Tick ( void )

If the farmer decision making model is on, the function:

calls FarmManager::ActualProfit() function on March 1st each year starting from the 2nd year of the simulation
starting from the 7th year, it saves the previous year's crop set for each farm and calls the FarmManager::ChooseDecisionMode_for_farms() function
saves all crop prices as last year prices (needed if crop prices are not constant)
saves the number of day degrees in a period March 1st - November 1st. See FarmManager::daydegrees.
modifies energy maize price each year if the model is run with energy maize.

Definition at line 1294 of file Landscape.cpp.

References cfg_productapplicendyear, cfg_productapplicstartyear, cfg_rodenticide_enable, Calendar::DayInYear(), g_date, g_pest, g_rand_uni(), g_weather, Calendar::GetYearNumber(), janfirst, Calendar::JanFirst(), l_map_dump_event_enable, l_map_dump_event_x1, l_map_dump_event_y1, l_map_dump_veg_enable, l_map_dump_veg_x, l_map_dump_veg_y, marchfirst, Calendar::MarchFirst(), Calendar::Tick(), Pesticide::Tick(), Weather::Tick(), toof_Foobar, tos_Foobar, tov_Maize, tov_Undefined, CfgInt::value(), and CfgBool::value().

                            {
     g_date->Tick();
     g_weather->Tick();
 
     // Remember todays LAItotal for veg elements
     for (unsigned int i = 0; i < m_elems.size(); i++) {
         m_elems[ i ]->StoreLAItotal();
     }
 
     // Update the growth curve phases if needed.
     if (g_date->JanFirst()) {
         if (g_rand_uni() > 0.5) {
             m_FarmManager->SetSpilledGrain( true );
         }
         else m_FarmManager->SetSpilledGrain( false );
         for (unsigned int i = 0; i < m_elems.size(); i++) {
             m_elems[ i ]->SetGrowthPhase( janfirst );
         }
     }
     else if (g_date->MarchFirst()) {
         for (unsigned int i = 0; i < m_elems.size(); i++) {
             m_elems[ i ]->SetGrowthPhase( marchfirst );
         }
         // Check and see if the pesticide engine flag should be set
         if ((SupplyYearNumber() >= cfg_productapplicstartyear.value()) && (SupplyYearNumber() <= cfg_productapplicendyear.value()))
             m_toxShouldSpray = true;
         else m_toxShouldSpray = false;
     }
 
 
     // Grow the green stuff and let the bugs have some too.
     for (unsigned int i = 0; i < m_elems.size(); i++) {
         m_elems[ i ]->Tick();
         m_elems[ i ]->DoDevelopment();
     }
 
     //call ActualProfit function, then save this year's crop prices - for the next year's expected results calculation, then change price
     if (cfg_OptimisingFarms.value()) {
         if (!cfg_OptimiseBedriftsmodelCrops.value()) { //do this just in almass crop mode
 
             if (g_date->DayInYear() == g_date->DayInYear( 1, 03 ) && g_date->GetYearNumber()>1) { //March 1st - do the accounting; 1 corresponds to 0 in the visual version year counter.
 
                 m_FarmManager->ActualProfit();
 
                 //print the m_cropTotals
                 ofstream ofile2( "CropDistribution.txt", ios::app );
                 // the distibution of crops from last year! 
                 int last_year = g_date->GetYearNumber() - 1;
                 ofile2 << last_year << '\t';
                 for (int c = 0; c < m_FarmManager->pm_data->Get_noCrops(); c++) ofile2 << m_FarmManager->Get_cropTotals( c ) << '\t';
                 ofile2 << endl;
                 //restart the m_cropTotals:
                 for (int i = 0; i < (int)m_FarmManager->Get_cropTotals_size(); i++) {
                     m_FarmManager->Set_cropTotals( i, 0 );
                 }
 
                 if (g_date->GetYearNumber() > 7) { //it's been 6 years since the first accounting was carried out (5 would be enough, but exclude one year to avoid start up effects)
                     m_FarmManager->Save_last_years_crops_for_farms(); //saves m_rotational_crops in m_rotational_crops_visible
                     m_FarmManager->ChooseDecisionMode_for_farms();
                 }
 
             }
 
             //save the last year crop price; 
             if (g_date->GetYearNumber() > 1 && g_date->DayInYear() == g_date->DayInYear( 1, 03 )) {
                 for (int f = 0; f < (toof_Foobar * tos_Foobar); f++) { //need to save the price for all farm types and soil types, so just run through the whole vector;
                     int no_crops = m_FarmManager->pm_data->Get_cropTypes_almass_size();
                     for (int c = 0; c < no_crops; c++) {
                         double old_price = m_FarmManager->pm_data->Get_sellingPrice( tov_Undefined*f + m_FarmManager->pm_data->Get_cropTypes_almass( c ) ); //get the current price
                         m_FarmManager->pm_data->Set_sellingPrice_lastyr( old_price, tov_Undefined*f + m_FarmManager->pm_data->Get_cropTypes_almass( c ) ); //save it
                     }
                 }
             }
             //-----
 
 
             if (cfg_MaizeEnergy.value()) { //modify energy maize price
 
                 if (g_date->DayInYear() == g_date->DayInYear( 1, 03 ) && g_date->GetYearNumber() != 0) { //print the price once a year
                     ofstream ofileEM( "Maize_energy_price_yearly.txt", ios::app );
                     int year = g_date->GetYearNumber();
                     ofileEM << year << '\t';
                     ofileEM << m_FarmManager->pm_data->Get_sellingPrice( tov_Maize );
                     ofileEM << endl;
                     ofileEM.close();
                 }
 
                 //changing price according to the input file EM_price.txt
                 if (g_date->DayInYear() == g_date->DayInYear( 1, 03 ) && g_date->GetYearNumber() > 0) {//exclude the hidden year
                     for (int f = 0; f < (toof_Foobar * tos_Foobar); f++) { //need to change the price for all farm types and soil types
                         double new_price = m_FarmManager->pm_data->Get_emaize_price( g_date->GetYearNumber() );
                         m_FarmManager->pm_data->Set_sellingPrice( new_price, tov_Undefined*f + tov_Maize );
                     }
                 }
             }// if energy maize
 
         }//almass crop mode
     }//optimising farms
 
     /*  Testing removal - may cause issues with increasing or decreasing permanent vegetation
     if ( g_date->DayInYear() == g_date->DayInYear( 1, 11 ) ) {
     // Set all elements to smooth curve transition mode at November 1st.
     for ( unsigned int i = 0; i < m_elems.size(); i++ ) {
     m_elems[ i ]->ForceGrowthInitialize();
     }
     //save the day degrees - used for crops that are not harvested instead of biomass to determine yield; done on Nov 1st
     //m_FarmManager->SetDD (SupplyTempPeriod( g_date->Date(), 245)); // from Nov 1 - 245 days back till March 1;
     //DegreesDump();
     }
     */
 
     // Put the farmers to work.
     m_FarmManager->FarmManagement();
 
 
     // Update pesticide information.
     g_pest->Tick();
 
     // Update rodenticide information if we are using this
     if (cfg_rodenticide_enable.value()) {
         m_RodenticideManager->Tick();
         m_RodenticidePreds->Tick();
     }
 
     // Dump event information if necessary
     if (l_map_dump_veg_enable.value()) VegDump( l_map_dump_veg_x.value(), l_map_dump_veg_y.value() );
     if (l_map_dump_event_enable.value())
         //EventDump( l_map_dump_event_x1.value(), l_map_dump_event_y1.value(), l_map_dump_event_x2.value(), l_map_dump_event_y2.value() );
         EventDumpPesticides( l_map_dump_event_x1.value(), l_map_dump_event_y1.value() );
 }

TTypesOfLandscapeElement Landscape::TranslateEleTypes ( int EleReference )

inline

Definition at line 1574 of file landscape.h.

References g_letype, and LE_TypeClass::TranslateEleTypes().

 {
   return g_letype->TranslateEleTypes( EleReference );
 }

TTypesOfVegetation Landscape::TranslateVegTypes ( int VegReference )

inline

Definition at line 1581 of file landscape.h.

References g_letype, and LE_TypeClass::TranslateVegTypes().

 {
   return g_letype->TranslateVegTypes( VegReference );
 }

void Landscape::TurnTheWorld ( void )

inline

Definition at line 826 of file landscape.h.

 {
   Tick();
 }

bool Landscape::UMarginTest	(	int	a_fieldpoly,
		int	a_borderpoly,
		int	a_x,
		int	a_y,
		int	a_width
	)

protected

Definition at line 2450 of file Landscape.cpp.

                                                                                                 {
   int index;
   int x_add[ 8 ] = { 1*a_width, 1*a_width, 0, -1*a_width, -1*a_width, -1*a_width, 0, 1*a_width };
   int y_add[ 8 ] = { 0, -1*a_width, -1*a_width, -1*a_width, 0, 1*a_width, 1*a_width, 1*a_width };
   int width = m_land->MapWidth();
   int height = m_land->MapHeight();
   // Scan anti-clockwise from center pixel coordinate.
   for ( unsigned int i = 0; i < 8; i++ ) {
     if ( ( a_x + x_add[ i ] >= width ) || ( a_x + x_add[ i ] < 0 ) || ( a_y + y_add[ i ] >= height )
          || ( a_y + y_add[ i ] < 0 ) ) {
            return true;
     }
     //continue;
     index = m_land->Get( a_x + x_add[ i ], a_y + y_add[ i ] );
     if ( ( index != a_fieldindex ) && ( index != a_marginindex ) ) return true;
   }
   return false;
 }

void Landscape::UnsprayedMarginAdd ( LE * a_field )

protected

Definition at line 2398 of file Landscape.cpp.

References g_msg, LE::GetValidX(), LE::GetValidY(), l_map_umargin_width, LE::SetArea(), LE::SetPoly(), LE::SetUnsprayedMarginPolyRef(), tole_UnsprayedFieldMargin, CfgInt::value(), MapErrorMsg::Warn(), and WARN_BUG.

                                                  {
   int x = a_field->GetValidX();
   int y = a_field->GetValidY();
   if ( ( x == -1 ) || ( y == -1 ) ) {
     // Tripping this probably means it is not a field
     g_msg->Warn( WARN_BUG, "Landscape::UnsprayedMarginAdd(): Uninitialized border coordinate!", "" );
     exit( 1 );
   }
   LE * umargin = NewElement( tole_UnsprayedFieldMargin );
   m_polymapping[ hb_first_free_poly_num ] =  (int) m_elems.size();
   m_elems.resize( m_elems.size() + 1 );
   m_elems[ m_elems.size() - 1 ] = umargin;
   a_field->SetUnsprayedMarginPolyRef( hb_first_free_poly_num );
   umargin->SetPoly( hb_first_free_poly_num++ );
   umargin->SetArea( 0.0 );
 
   for ( int q = 0; q < l_map_umargin_width.value(); q++ )
     UnsprayedMarginScan( a_field, q + 1 );
 }

void Landscape::UnsprayedMarginScan	(	LE *	a_field,
		int	a_width
	)

protected

Definition at line 2419 of file Landscape.cpp.

References LE::AddArea(), LE::GetPoly(), LE::GetUnsprayedMarginPolyRef(), LE::GetValidX(), LE::GetValidY(), and SupplyLEPointer().

                                                                {
   LE * umargin = g_landscape_p->SupplyLEPointer( a_field->GetUnsprayedMarginPolyRef() );
   int fieldpoly = a_field->GetPoly();
   int borderpoly = umargin->GetPoly();
   int borderindex = m_polymapping[ borderpoly ];
   int fieldindex = m_polymapping[ fieldpoly ];
   int notforever = 5000;
 
   // These two will be modified through pointer operations
   // in BorderStep().
   int x = a_field->GetValidX();
   int y = a_field->GetValidY();
   // Now the problem is that GetValid does not always return a valid co-ord!
   // so we need to search for one
   if ( !FindValidXY( fieldindex, x, y ) ) return;
 
   while ( --notforever ) {
     // Check if this position should be made into a border.
     if ( UMarginTest( fieldindex, borderindex, x, y, a_width ) ) {
       // Add this pixel to the border element in the big map.
       m_land->Put( x, y, borderindex );
       a_field->AddArea( -1.0 );
       umargin->AddArea( 1.0 );
     };
     // Step to next coordinate. Quit when done.
     if ( !BorderStep( fieldindex, borderindex, & x, & y ) )
       return;
   }
 }

void Landscape::VegDump	(	int	x,
		int	y
	)

protected

Definition at line 1456 of file Landscape.cpp.

References g_msg, MapErrorMsg::Warn(), and WARN_FILE.

                                       {
   FILE * vfile=fopen("VegDump.txt", "a" );
   if (!vfile) {
     g_msg->Warn( WARN_FILE, "Landscape::VegDump(): Unable to open file", "VegDump.txt" );
     exit( 1 );
   }
   int year = SupplyYearNumber();
   int day = SupplyDayInYear();
   double hei = SupplyVegHeight( x, y );
   double bio = SupplyVegBiomass( x, y );
   double cover = SupplyVegCover( x, y );
   double density = bio / ( hei + 1 );
   double weeds = SupplyWeedBiomass( x, y );
   double insects = SupplyInsects( x, y );
   double LATotal = SupplyLATotal(x, y);
   double LAGreen = SupplyLAGreen(x, y);
   double digest = SupplyVegDigestability(x, y);
   double GreenBiomass = SupplyGreenBiomass(x,y);
   double DeadBiomass = SupplyDeadBiomass(x,y);
   int grazed = SupplyGrazingPressure(x, y);
   double ggraze = GetActualGooseGrazingForage(m_land->Get(x, y), gs_Pinkfoot);
   int VegType = BackTranslateVegTypes(SupplyVegType(x, y));
   double grain = SupplyBirdSeedForage(x, y);
 
   fprintf( vfile, "%d\t%d\t%g\t%g\t%d\t%g\t%g\t%g\t%i\t%g\t%g\t%g\t%g\t%g\t%g\t%g\t%g\n", year, day, hei, bio, grazed, density, cover, weeds, VegType, insects, LATotal, LAGreen, digest, GreenBiomass, DeadBiomass, ggraze, grain );
   /*
   y += 100;
   x += 100;
   hei = SupplyVegHeight( x, y );
   bio = SupplyVegBiomass( x, y );
   cover = SupplyVegCover( x, y );
   density = bio / ( hei + 1 );
   weeds = SupplyWeedBiomass( x, y );
   VegType = SupplyVegType( x, y );
   insects = SupplyInsects( x, y );
   digest = SupplyVegDigestability(x,y);
   fprintf( vfile, "%g\t%g\t%g\t%g\t%g\t%i\t%g\t%g\n", hei, bio, density, cover, weeds, VegType, insects, digest );
   */
   fclose( vfile );
 }

std::string Landscape::VegtypeToString ( TTypesOfVegetation a_veg )

Definition at line 3943 of file Landscape.cpp.

References g_msg, tov_AgroChemIndustryCereal, tov_BroadBeans, tov_Carrots, tov_CloverGrassGrazed1, tov_CloverGrassGrazed2, tov_FieldPeas, tov_FieldPeasSilage, tov_FieldPeasStrigling, tov_FodderBeet, tov_FodderGrass, tov_Heath, tov_Lawn, tov_Maize, tov_MaizeSilage, tov_MaizeStrigling, tov_NaturalGrass, tov_NoGrowth, tov_None, tov_Oats, tov_OBarleyPeaCloverGrass, tov_OCarrots, tov_OCloverGrassGrazed1, tov_OCloverGrassGrazed2, tov_OCloverGrassSilage1, tov_OFieldPeas, tov_OFieldPeasSilage, tov_OFirstYearDanger, tov_OFodderBeet, tov_OGrazingPigs, tov_OMaizeSilage, tov_OOats, tov_OPermanentGrassGrazed, tov_OPotatoes, tov_OrchardCrop, tov_OSBarleySilage, tov_OSeedGrass1, tov_OSeedGrass2, tov_OSetaside, tov_OSpringBarley, tov_OSpringBarleyClover, tov_OSpringBarleyExt, tov_OSpringBarleyGrass, tov_OSpringBarleyPigs, tov_OTriticale, tov_OWinterBarley, tov_OWinterBarleyExt, tov_OWinterRape, tov_OWinterRye, tov_OWinterWheat, tov_OWinterWheatUndersown, tov_OWinterWheatUndersownExt, tov_PermanentGrassGrazed, tov_PermanentGrassLowYield, tov_PermanentGrassTussocky, tov_PermanentSetaside, tov_PlantNursery, tov_Potatoes, tov_PotatoesIndustry, tov_SeedGrass1, tov_SeedGrass2, tov_Setaside, tov_SpringBarley, tov_SpringBarleyCloverGrass, tov_SpringBarleyCloverGrassStrigling, tov_SpringBarleyGrass, tov_SpringBarleyPeaCloverGrassStrigling, tov_SpringBarleyPTreatment, tov_SpringBarleySeed, tov_SpringBarleySilage, tov_SpringBarleySKManagement, tov_SpringBarleySpr, tov_SpringBarleyStrigling, tov_SpringBarleyStriglingCulm, tov_SpringBarleyStriglingSingle, tov_SpringRape, tov_SpringWheat, tov_SugarBeet, tov_Triticale, tov_Undefined, tov_Wasteland, tov_WinterBarley, tov_WinterBarleyStrigling, tov_WinterRape, tov_WinterRapeStrigling, tov_WinterRye, tov_WinterRyeStrigling, tov_WinterWheat, tov_WinterWheatShort, tov_WinterWheatStrigling, tov_WinterWheatStriglingCulm, tov_WinterWheatStriglingSingle, tov_WWheatPControl, tov_WWheatPToxicControl, tov_WWheatPTreatment, tov_YoungForest, MapErrorMsg::Warn(), and WARN_FILE.

                                                              {
     char error_num[20];
 
     switch (a_veg) {
     case tov_Carrots:
         return "Carrots              ";
     case tov_BroadBeans:
         return "BroadBeans           ";
     case tov_FodderGrass:
         return "FodderGrass          ";
     case tov_CloverGrassGrazed1:
         return "CloverGrassGrazed1   ";
     case tov_CloverGrassGrazed2:
         return "CloverGrassGrazed2   ";
     case tov_FieldPeas:
         return "FieldPeas            ";
     case tov_FieldPeasSilage:
         return "FieldPeasSilage      ";
     case tov_FodderBeet:
         return "FodderBeet           ";
     case tov_SugarBeet:
         return "SugarBeet            ";
     case tov_OFodderBeet:
         return "OFodderBeet          ";
     case tov_Lawn:
         return "Lawn                 ";
     case tov_Maize:
         return "Maize                ";
     case tov_MaizeSilage:
         return "MaizeSilage          ";
     case tov_OMaizeSilage:
         return "OMaizeSilage         ";
     case tov_NaturalGrass:
         return "NaturalGrass         ";
     case tov_NoGrowth:
         return "NoGrowth             ";
     case tov_None:
         return "None                 ";
     case tov_OrchardCrop:
         return "OrchardCrop          ";
     case tov_Oats:
         return "Oats                 ";
     case tov_OBarleyPeaCloverGrass:
         return "OBarleyPeaCloverGrass";
     case tov_OCarrots:
         return "OCarrots             ";
     case tov_OCloverGrassGrazed1:
         return "OCloverGrassGrazed1  ";
     case tov_OCloverGrassGrazed2:
         return "OCloverGrassGrazed2  ";
     case tov_OCloverGrassSilage1:
         return "OCloverGrassSilage1  ";
     case tov_OFieldPeas:
         return "OFieldPeas           ";
     case tov_OFieldPeasSilage:
         return "OFieldPeasSilage     ";
     case tov_OFirstYearDanger:
         return "OFirstYearDanger     ";
     case tov_OGrazingPigs:
         return "OGrazingPigs         ";
     case tov_OOats:
         return "OOats                ";
     case tov_OPermanentGrassGrazed:
         return "OPermanentGrassGrazed";
     case tov_OPotatoes:
         return "OPotatoes            ";
     case tov_OSBarleySilage:
         return "OSBarleySilage       ";
     case tov_OSeedGrass1:
         return "OSeedGrass1          ";
     case tov_OSeedGrass2:
         return "OSeedGrass2          ";
     case tov_OSetaside:
         return "OSetaside             ";
     case tov_OSpringBarley:
         return "OSpringBarley        ";
     case tov_OSpringBarleyExt:
         return "OSpringBarleyExt     ";
     case tov_OSpringBarleyClover:
         return "OSpringBarleyClover  ";
     case tov_OSpringBarleyGrass:
         return "OSpringBarleyGrass   ";
     case tov_OSpringBarleyPigs:
         return "OSpringBarleyPigs    ";
     case tov_OTriticale:
         return "OTriticale           ";
     case tov_OWinterBarley:
         return "OWinterBarley        ";
     case tov_OWinterBarleyExt:
         return "OWinterBarleyExt     ";
     case tov_OWinterRape:
         return "OWinterRape          ";
     case tov_OWinterRye:
         return "OWinterRye           ";
     case tov_OWinterWheatUndersown:
         return "OWinterWheatUndersown";
     case tov_OWinterWheat:
         return "OWinterWheat";
     case tov_OWinterWheatUndersownExt:
         return "OWinterWheatUsowExt  ";
     case tov_PermanentGrassGrazed:
         return "PermanentGrassGrazed ";
     case tov_PermanentGrassLowYield:
         return "PermanentGrassLowYield";
     case tov_PermanentGrassTussocky:
         return "PermanentGrassTussocky";
     case tov_PermanentSetaside:
         return "PermanentSetaside    ";
     case tov_Potatoes:
         return "PotatoesEat          ";
     case tov_PotatoesIndustry:
         return "PotatoesIndustry     ";
     case tov_SeedGrass1:
         return "SeedGrass1           ";
     case tov_SeedGrass2:
         return "SeedGrass2           ";
     case tov_Setaside:
         return "Setaside             ";
     case tov_SpringBarley:
         return "SpringBarley         ";
     case tov_SpringBarleySpr:
         return "SpringBarleySpr      ";
     case tov_SpringBarleyPTreatment:
         return "SpringBarleyPTreat   ";
     case tov_SpringBarleySKManagement:
         return "SpringBarleySKMan    ";
     case tov_SpringBarleyCloverGrass:
         return "SprBarleyCloverGrass ";
     case tov_SpringBarleyGrass:
         return "SpringBarleyGrass    ";
     case tov_SpringBarleySeed:
         return "SpringBarleySeed     ";
     case tov_SpringBarleySilage:
         return "SpringBarleySilage   ";
     case tov_SpringRape:
         return "SpringRape           ";
     case tov_SpringWheat:
         return "SpringWheat          ";
     case tov_AgroChemIndustryCereal:
         return "AgroChemIndustry Cereal      ";
     case tov_Triticale:
         return "Triticale            ";
     case tov_WinterBarley:
         return "WinterBarley         ";
     case tov_WinterRape:
         return "WinterRape           ";
     case tov_WinterRye:
         return "WinterRye            ";
     case tov_WinterWheat:
         return "WinterWheat          ";
     case tov_WinterWheatShort:
         return "WinterWheatShort     ";
     case tov_WWheatPControl:
         return "P Trial Control      ";
     case tov_WWheatPToxicControl:
         return "P Trial Toxic Control";
     case tov_WWheatPTreatment:
         return "P Trial Treatment    ";
     case tov_Undefined:
         return "Undefined            ";
     case tov_WinterWheatStrigling:
         return "WWStrigling          ";
     case tov_WinterWheatStriglingSingle:
         return "WWStriglingSingle    ";
     case tov_WinterWheatStriglingCulm:
         return "WWStriglingCulm      ";
     case tov_SpringBarleyCloverGrassStrigling:
         return "SBPCGStrigling       ";
     case tov_SpringBarleyStrigling:
         return "SBarleyStrigling     ";
     case tov_SpringBarleyStriglingSingle:
         return "SBarleyStriglingSgl  ";
     case tov_SpringBarleyStriglingCulm:
         return "SBarleyStriglingCulm ";
     case tov_MaizeStrigling:
         return "MaizseStrigling      ";
     case tov_WinterRapeStrigling:
         return "WRapeStrigling       ";
     case tov_WinterRyeStrigling:
         return "WRyeStrigling        ";
     case tov_WinterBarleyStrigling:
         return "WBStrigling          ";
     case tov_FieldPeasStrigling:
         return "FieldPeasStrigling   ";
     case tov_SpringBarleyPeaCloverGrassStrigling:
         return "SBPeaCloverGrassStr  ";
     case tov_YoungForest:
         return "Young Forest         ";
     case tov_Wasteland:
         return "Wasteland            ";
     case tov_Heath:
         return "Heath/Grass          ";
     case  tov_PlantNursery:
         return "Plant Nursery        ";
 
     default:
         sprintf(error_num, "%d", a_veg);
         g_msg->Warn(WARN_FILE, "Landscape::VegtypeToString(): Unknown event type:", error_num);
         exit(1);
     }
 }

void Landscape::Warn	(	std::string	a_msg1,
		std::string	a_msg2
	)

inline

Definition at line 1505 of file landscape.h.

References g_msg, MapErrorMsg::Warn(), and WARN_MSG.

Referenced by Rabbit_Population_Manager::ClassifyHabitat(), Rabbit_Warren::DEBUG_InternalTest(), Rabbit_Warren::DEBUG_InternalTest2(), Rabbit_Warren::JoinNOccupy(), Rabbit_Warren::Leave(), Rabbit_Adult::OnMateDead(), Rabbit_Adult::OnMateFinishedDigging(), Rabbit_Female::OnYoungDeath(), Rabbit_Female::Rabbit_Female(), Rabbit_Adult::SetMate(), Rabbit_Female::st_EvaluateTerritory(), Rabbit_Young::Step(), Rabbit_Juvenile::Step(), Rabbit_Male::Step(), Rabbit_Female::Step(), Rabbit_Warren::Step(), and Rabbit_Female::Weaned().

 {
   g_msg->Warn( WARN_MSG, a_msg1, a_msg2 );
 }

void Landscape::WriteOpenness ( void )

Stores openness for all polygons to a standard file.

Member Data Documentation

int Landscape::hb_border_pixels

protected

Definition at line 254 of file landscape.h.

Referenced by hb_Add(), and hb_PaintBorder().

int Landscape::hb_core_pixels

protected

Definition at line 253 of file landscape.h.

Referenced by hb_Add(), and hb_PaintBorder().

int Landscape::hb_first_free_poly_num

protected

Definition at line 252 of file landscape.h.

Referenced by hb_GenerateHBPolys().

vector<int> Landscape::hb_hedges

protected

Definition at line 241 of file landscape.h.

Referenced by hb_Add(), and hb_FindHedges().

int Landscape::hb_height

protected

Definition at line 248 of file landscape.h.

Referenced by hb_Add(), hb_FindBoundingBox(), hb_HasNeighbourColor(), hb_MapBorder(), and hb_MaxUnpaintedNegNeighbour().

int* Landscape::hb_map

protected

Definition at line 246 of file landscape.h.

Referenced by hb_Add(), hb_AddNewHedgebanks(), hb_ClearPolygon(), hb_DownPolyNumbers(), hb_FindBoundingBox(), hb_HasNeighbourColor(), hb_HasOtherNeighbour(), hb_MarkTheBresenhamWay(), hb_MarkTopFromLocalMax(), hb_MaxUnpaintedNegNeighbour(), hb_PaintBorder(), hb_PaintWhoHasNeighbourColor(), hb_ResetColorBits(), hb_RestoreHedgeCore(), and hb_UpPolyNumbers().

int Landscape::hb_max_x

protected

Definition at line 250 of file landscape.h.

Referenced by hb_AddNewHedgebanks(), hb_ClearPolygon(), hb_FindBoundingBox(), hb_MarkTheBresenhamWay(), hb_MarkTopFromLocalMax(), hb_PaintBorder(), hb_PaintWhoHasNeighbourColor(), hb_ResetColorBits(), and hb_RestoreHedgeCore().

int Landscape::hb_max_y

protected

Definition at line 251 of file landscape.h.

Referenced by hb_AddNewHedgebanks(), hb_ClearPolygon(), hb_FindBoundingBox(), hb_MarkTheBresenhamWay(), hb_MarkTopFromLocalMax(), hb_PaintBorder(), hb_PaintWhoHasNeighbourColor(), hb_ResetColorBits(), and hb_RestoreHedgeCore().

int Landscape::hb_min_x

protected

Definition at line 250 of file landscape.h.

Referenced by hb_AddNewHedgebanks(), hb_ClearPolygon(), hb_FindBoundingBox(), hb_MarkTheBresenhamWay(), hb_MarkTopFromLocalMax(), hb_PaintBorder(), hb_PaintWhoHasNeighbourColor(), hb_ResetColorBits(), and hb_RestoreHedgeCore().

int Landscape::hb_min_y

protected

Definition at line 251 of file landscape.h.

Referenced by hb_AddNewHedgebanks(), hb_ClearPolygon(), hb_FindBoundingBox(), hb_MarkTheBresenhamWay(), hb_MarkTopFromLocalMax(), hb_PaintBorder(), hb_PaintWhoHasNeighbourColor(), hb_ResetColorBits(), and hb_RestoreHedgeCore().

vector<LE*> Landscape::hb_new_hbs

protected

Definition at line 242 of file landscape.h.

Referenced by hb_GenerateHBPolys(), and hb_StripingDist().

int Landscape::hb_size

protected

Definition at line 249 of file landscape.h.

Referenced by hb_Add(), hb_DownPolyNumbers(), and hb_UpPolyNumbers().

int Landscape::hb_width

protected

Definition at line 247 of file landscape.h.

Referenced by hb_Add(), hb_AddNewHedgebanks(), hb_ClearPolygon(), hb_DownPolyNumbers(), hb_FindBoundingBox(), hb_HasNeighbourColor(), hb_HasOtherNeighbour(), hb_MapBorder(), hb_MarkTheBresenhamWay(), hb_MarkTopFromLocalMax(), hb_MaxUnpaintedNegNeighbour(), hb_PaintBorder(), hb_PaintWhoHasNeighbourColor(), hb_ResetColorBits(), and hb_RestoreHedgeCore().

double* Landscape::l_vegtype_areas

private

Definition at line 141 of file landscape.h.

int Landscape::le_signal_index

protected

Definition at line 297 of file landscape.h.

bool Landscape::m_DoMissingPolygonsManipulations

private

Flag to signal that missing polygons exist

Definition at line 138 of file landscape.h.

vector<LE*> Landscape::m_elems

private

List of all landscape elements. The index is a sequential number, to get the polynum look this number up in m_polymapping.

Definition at line 119 of file landscape.h.

Referenced by hb_Add(), hb_DownPolyNumbers(), hb_FindHedges(), and hb_GenerateHBPolys().

FarmManager* Landscape::m_FarmManager

private

List of all the farms.

Definition at line 116 of file landscape.h.

Polynomial2CurveClass* Landscape::m_GooseIntakeRateVSVegetationHeight_BG

private

Definition at line 149 of file landscape.h.

Polynomial2CurveClass* Landscape::m_GooseIntakeRateVSVegetationHeight_GL

private

Definition at line 150 of file landscape.h.

Polynomial2CurveClass* Landscape::m_GooseIntakeRateVSVegetationHeight_PF

private

Curve relatning goose intake rates in KJ/min to vegetation height.

Definition at line 148 of file landscape.h.

int Landscape::m_height

private

Definition at line 128 of file landscape.h.

int Landscape::m_height10

private

Definition at line 130 of file landscape.h.

RasterMap* Landscape::m_land

private

The big map.

Definition at line 122 of file landscape.h.

Referenced by hb_Add().

int Landscape::m_LargestPolyNumUsed

protected

Definition at line 172 of file landscape.h.

int Landscape::m_maxextent

private

Definition at line 131 of file landscape.h.

bool Landscape::m_NeedCentroidCalculation

private

a flag to ensure centroid calculation on object construction

Definition at line 134 of file landscape.h.

bool Landscape::m_NeedOpennessCalculation

private

a flag to ensure openness calculation on object construction

Definition at line 136 of file landscape.h.

TTypesOfPesticide Landscape::m_PesticideType

protected

An attribute to hold the pesticide type being tested, if there is one, if not default is -1.

Definition at line 256 of file landscape.h.

vector<int> Landscape::m_PondIndexList

protected

List of pond indexes.

Definition at line 175 of file landscape.h.

vector<int> Landscape::m_PondRefsList

protected

List of pond polyrefs.

Definition at line 177 of file landscape.h.

RodenticideManager* Landscape::m_RodenticideManager

private

Definition at line 145 of file landscape.h.

RodenticidePredators_Population_Manager* Landscape::m_RodenticidePreds

private

Definition at line 146 of file landscape.h.

Population_Manager* Landscape::m_ThePopManager

private

a pointer to the current main population manager

Definition at line 143 of file landscape.h.

bool Landscape::m_toxShouldSpray

protected

Definition at line 295 of file landscape.h.

int Landscape::m_treatment_counts[last_treatment]

protected

Definition at line 171 of file landscape.h.

char Landscape::m_versioninfo[30]

private

Definition at line 112 of file landscape.h.

int Landscape::m_width

private

Definition at line 127 of file landscape.h.

int Landscape::m_width10

private

Definition at line 129 of file landscape.h.

int Landscape::m_x_add[8]

protected

Definition at line 244 of file landscape.h.

int Landscape::m_y_add[8]

protected

Definition at line 245 of file landscape.h.

The documentation for this class was generated from the following files:

D:/CJT/Repos/ALMaSS_all/Landscape/landscape.h
D:/CJT/Repos/ALMaSS_all/Landscape/hedgebanks.cpp
D:/CJT/Repos/ALMaSS_all/Landscape/Landscape.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation